Common pitfalls when using arrays: Trusting type-unsafe linking

Question

I was reading this link How do I use arrays in C++?, section 5. Common pitfalls when using arrays, where an example is given as following:

// [numbers.cpp]
int numbers[42] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

// [main.cpp]
extern int* numbers;
int main()
{}

Since 'numbers' in numbers.cpp is the name of array, which can normally decay to a pointer equals to '&numbers[0]', I would expect in main.cpp value of 'numbers' is still '&numbers[0]'. But no! it is instead 'numbers[0]', i.e. '1'.

Or let's say I am the compiler, in 'numbers.cpp', I see the symbol 'numbers' as an address pointing to '1', why is this same symbol changed to value 1' in 'main.cpp'?

I understand that's what author says "type-unsafe linking". But I do not know why compiler does this, even if compiler just raise a type-mismatch link error make more sense to me.

Comments

I guess my understanding is, compiler see below as equivalent, so that linker succeed, otherwise will have 'unresolved externals' error:

// [numbers.cpp]
int tmp[42] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; //{1,..9} starts at global address 0x1234
int *numbers = &tmp[0];                    //numbers == 0x1234

// [main.cpp]
extern int* numbers;                       //numbers == 0x1234
int main()
{}

The real situation:

// [numbers.cpp]
int numbers[42] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; //{1,..9} starts at global address 0x1234

// [main.cpp]
extern int* numbers;                       //numbers == numbers[0] == 1
int main()
{}

Answer 1

Does the following way of explaining it help:

When a is an array (i.e. when the compiler knows that the type of a is an array type), then the syntax a[i] is interpreted as: Return the ith element of the array.

On the other hand, when a is a pointer (to the first element of an array), then the same syntax, a[i], is interpreted as: Look up the address stored in a, add the number of bytes that corresponds to i elements, and return the value stored there.

In main.cpp, it thinks that numbers is a pointer^(*) and applies the corresponding actions. That is, it looks up the value stored in numbers, treats that as an address, adds an amount of bytes and returns the value stored at that address.

^(*)It does this because numbers is declared as a pointer there. The compiler doesn't know that it really is an array, because main.cpp is compiled separately from numbers.cpp (i.e. it is a separate translation unit). So it doesn't decay the array into a pointer – it simply assumes it is a pointer already.

Answer 2

If numbers is an array, eg. numbers[], then you cannot change what it points to. The object file will map the symbol "numbers" to the actual array, {1, 2, ...} But if numbers is a pointer, eg. *numbers, then you can change what it points to, and the object file will map the symbol "numbers" to a single pointer value (that may itself point to the beginning of an array, but we don't know that).

Arrays and pointers act similar, but are not the same thing.

Answer 3

In C++ the typical answer is "use a container". For array-like containers, std::vector is usually what you want. If you want maximum performance, std::valarray may be a better option (of course the performance is if you use it like its meant to be used, such as with gslice).

A better article would be "When would I use C style arrays with C++". Answer: almost never, unless you have to interface to other software.