这些C ++中的extern声明有什么区别？

Question

Lets have the files with the following contents:

file1.cpp : double array[100];

file2.cpp (client of file1.cpp ):

/// What the difference between this:
extern double* array;

/// and this?
extern double array[];

If I use array declared in the first way I receive segfault. If second, it works ok. It confuses me, since in a regular C++ programm I can easily do the following and these objects would be equal:

double array[100];
double* same_array = array;

/// array[0] is equal to same_array[0] here
/// But why they are not equal in the example with extern?

Answer 1

The difference is that first is an pointer to the type double
and second is an array of double.

Important thing to note here is:

Arrays are not Pointers!

An expression with array type (which could be an array name) will convert to a pointer anytime an array type is not legal, but a pointer type is.

double array[100];
double* same_array = array;

As per the rule mentioned,In above the array name decays in to a pointer to its first element.

Why does your program crash?
An array declaration creates an array which occupies some memory depending on the storage class(where is declared).
While a pointer just creates an pointer which points to some address. You would explicitly need to made it point to some valid object to be able to use it.

This should be a good read:
How do I use arrays in C++?

Answer 2

extern double* array;

When you now do array[i] , and at some place array is actually defined as an array (instead of as a pointer like above), then it will try to interpret the contents of the array as an address. So for example in another file/another translation unit we defined at as

double array[1] = { 0.0 };

Let's assume that 0.0 has all bits zero. Then the array[1] operation on the extern double* above would try to dereference a pointer address having all bits zero. On most boxes, that will crash. And on the remaining others it would result in random nonsense.