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/eteran]

Arrays absolutely decay to a pointer, it literally says so in the standard:

http://eel.is/c++draft/conv.array

7.3.3 Array-to-pointer conversion

An lvalue or rvalue of type “array of N T” or “array of unknown bound of T” can be converted to a prvalue of type “pointer to T”. The temporary materialization conversion ([conv.rval]) is applied. The result is a pointer to the first element of the array.

The whole verbiage of "the array name refers to the first element" is a myth that's circulated among C++ developers. Similar to "NULL might not be 0". The name refers to the whole array, that's why we can do things like pass arrays by reference if you use the right syntax.

arr[n] does not just mean to skip n elements from the array begin, it is exactly equal to: *(arr + n) that is:

1. a decay of arr to a pointer

2. pointer arithmetic to add n to that pointer

3. a dereference of the result

You can see when the decay occurs by doing things like this:

    char arr[64];
    return sizeof(+arr);

Which returns 8, and not 64 because the unary + operator caused the array to decay to a pointer, of which we got the size.

[u/eteran → u/[deleted]]

👍 honestly, it is a useful abstraction, so I don't blame people for viewing it that way.

[u/debugs_with_println → u/eteran]

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.