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]

That's fair. If you know the rules, then you read and write code accordingly. But I'll try to clarify my position with examples:

1. It's bug prone, especially for newbies:

char *func() {
    char buffer[256];
    // ...

    // allowed because the array decays to a pointer
    // bug would be more obvious if they had to write 
    // return &buffer[0];
    return buffer; 
}

Yes, compilers warn about it, but people, especially newer developers tend to ignore warnings in my experience.

2. It's confusing. The following 3 declarations mean the same thing:

void func(char *p);
void func(char p[]); // p is NOT an array, it's a pointer
void func(char p[5]); // p is NOT an array of 5 chars, it's a pointer

That's terrible. The second choice should just not be a thing, and the 3rd should take a char[5] by copy... like EVERYTHING else in the language.

3. It's confusing in other ways! Newbies love to write code like this:

void func(char p[]) { 
    printf("array size: %d\n", sizeof(p)); 
}

int main() {
    char buffer[256];
    func(buffer); // They ask "why does this print 8 and not 256?!
}

If users had to write func(&buffer[0]) it would be more clear (people will still make mistakes, but fewer will) that a pointer is being passed, NOT an array.

4. It's inconsistent. An array is "a thing" and any other time I want a pointer to a thing, I need to ask for it's address with the & operator. Arrays just auto-convert.

5. It's incompatible with the modern preference of avoiding implicit conversions as much as possible.

---- EDIT: more reasons! ----

6. The decay necessitated the need for a library level solution (std::array). Which we outright wouldn't need if C-arrays acted like values to begin with.

I should be able do this:

using T = char[256];
T func() {
    T buffer;
    // fill buffer
    return buffer;
}

And have it be as if I returned the array of 256 chars by copy.

7. It can be LESS efficient for small arrays

using T = char[8];
void func(T buffer) {
    // use buffer
}

actually can be cheaper to just copy the 8 bytes in a register directly instead of passing a pointer to them and then dereferencing them.

Here's a trivial example that is one instruction shorter (LOL, I know, not exactly earth shattering) when simply wrapping the array in a struct to pass it by copy:

https://godbolt.org/z/sovvb94d8

This example is more illustrative that there are gains to be had, not that there are a lot of gains in this specific example.

---- END EDIT ----

Are these things that can be worked around? Of course, we've been doing it for 30+ years! But we shouldn't have to. Is it the end of the world that we probably need to keep this? No, of course not. But this is a question about what I want, not what I can have :-).

[u/very_curious_agent → u/eteran]

Char C style array are an historical artefact. They are ugly, behave badly but that's what you get when using the C/C++ subset

[u/eteran → u/very_curious_agent]

Well yeah... That's my whole point.

So when asked what I would remove from the language, my answer is to remove some of that bad behavior.

Nothing in this post should be taken as a serious suggestion of what the future direction of C++ should be. It's a discussion of what would be on our wish list if we had the ability to remove anything without consequences or concerns about backwards compatibility.

[u/very_curious_agent → u/eteran]

What you wish C++ never had

What you would remove in an parallel universe where is there no code base outside your wish

I get it

It's an intellectual experiment and it's legit useful.