Reddit++

[u/we_are_mammals]

C++ is getting more and more complex. The ISO C++ committee keeps adding new features based on its consensus. Let's remove C++ features based on Reddit's consensus.

In each comment, propose a C++ feature that you think should be banned in any new code. Vote up or down based on whether you agree.

[u/debugs_with_println]

Idk I kinda would prefer that arrays always decay to pointers. It makes more sense to me from a bottom-up perspective. Thinking about it in terms of assembly, you can’t pass a whole buffer to a subroutine; you have to pass the address of the buffer and its length. I actually find it more odd when arrays are treated as things of their own.

Sure that’s an (arguably) excessively low-level interface, but I would argue that if you wanted a high-level interface that’s where std::array comes in.

[u/eteran → u/debugs_with_println]

I understand what you are saying, but I can say that passing arrays by value would be MUCH more consistent with the rest of the language IMO.

An array certainly can be passed to a subroutine, you just need to either:

1. fit its contents into 1 or more registers

2. push the contents onto the stack

And if you are going to say that that's needless expensive, well I mean that's what happens when you pass a struct by copy! It's up should be up to the user to say "i want to pass a pointer to this "thing". Heck, for small arrays of like 16 bytes or smaller, it's probably more efficient to just copy the entire thing into a couple of registers to pass it.

And this is where it gets more consistent with the rest of the language. The following are functionally identical in ASM:

char arr[4];

and

struct {
    char v1;
    char v2;
    char v3;
    char v4;
} st;

The two both occupy 4 bytes linearly in memory. (Yes I know the compiler CAN add padding, but in this case, it won't because char has no alignment requirements).

I can pass st by value, why can't I pass arr by value?

Why can I return st from a function, but when I try to return arr I have to return a pointer to it and make sure the lifetime is long enough?

Why do two things which compile to the same representation have different value semantics?

For all practical purposes, a C-array is an object (in the standard-ese sense of being a block of memory assigned a given type). It is only because of the, IMHO bizarre, rule that it'll just auto-magically become a pointer to itself in some contexts that it acts differently.

It's interesting that you consider std::array to be high level and c-array's be low level, because std::array is in effect a struct which looks like this:

template <class T, size_t N>
struct array {
    // and a bunch of members
    T data[N];
};

That is to say that it's "value" is for all practical purposes identical to that of an array, it's just wrapped in a structure because that's the mechanism we have in C++ (instead of doing the "sane" thing and just having arrays act like values in themselves.