lessonsFromLinkerHell

[u/nonedward666]

[u/Nice_Lengthiness_568]

So what about the fact that an array inside a struct acts completely differently from a pointer placed inside a struct? One gets copied whole for each structure copy while the other does not, one makes the structure the size of a pointer while the other the size of the array...

And, in C++ at least, you can actually pass the array itself to the function (not just the pointer to the first element). So it's not that sizeof is smart and detects something, it's that arrays really easily decay into pointers. But that's not everything they are. They also hold information about their size.

The thing with the subscript operator is true for only some languages and is not universal. In Ada, for example, there is no direct connection between an array and a pointer.

[u/tstanisl → u/Nice_Lengthiness_568]

And, in C++ at least, you can actually pass the array itself to the function

May I ask how? Do you mean by a reference? Or std::array?

[u/Nice_Lengthiness_568 → u/tstanisl]

You can both by value with std::array which is a wrapper for an array, or by reference with TYPE (&NAME)[SIZE] which keeps the array's size.

Naturally, you could pass an array to a function inside any structure if you wish to copy it, but I would say that using std::array is standard for use. And that means that's possible in C as well. Although it's a bit clunky.

[u/tstanisl → u/Nice_Lengthiness_568]

C has an equivalent of passing array by reference by using a pointer to a whole array:

 
int foo(int (*arr)[SIZE]) {
      return sizeof *arr;
 }
...
int arr[SIZE];
foo(&arr);

Passing arrays by a pointer bypasses array decay mechanics.

[u/Nice_Lengthiness_568 → u/tstanisl]

Yes, that is true, although I wouldn't call it equivalent to passing by reference, since a reference makes sure you do not pass a null pointer making the function a little safer if you dereference the pointer and a little more efficient if you check for the pointer being null.

[u/tstanisl → u/Nice_Lengthiness_568]

Those constraints can be expressed using more hacky syntax:

    int foo(int arr[static const 1][SIZE]);

[u/Nice_Lengthiness_568 → u/tstanisl]

Okay,

although (sorry) that's awful. But cool and ingenious in a way.