c++ - ¿Por qué `& array` y` array` apuntan a la misma dirección?

arrays pointers

Question

Hasta ahora, pensé que una matriz es lo mismo que un puntero. Pero encontré un caso extraño:

código

int array[5] = { 10,11,12,13,14};

std::cout << array << std::endl;
std::cout << &array << std::endl;
std::cout << &array[0] << std::endl;

int *pArray = new int[5];

std::cout << pArray << std::endl;
std::cout << &pArray << std::endl;
std::cout << &pArray[0] << std::endl;

salida

0x7ffeed730ad0
0x7ffeed730ad0
0x7ffeed730ad0

0x7f906d400340
0x7ffeed730a30
0x7f906d400340

Como puede ver, la array y la &array tienen el mismo valor. Pero pArray y &pArray tienen un valor diferente. Si la matriz es igual que el puntero, la dirección de la matriz debe ser diferente de la matriz. ¿Cómo pueden ser iguales la &array ? Si la array y la &array son iguales, ¿cuál es la dirección de la memoria que contiene los valores de la matriz?

Answer 1

La array simple se desintegra a un puntero a su primer elemento, es igual a &array[0] . También sucede que el primer elemento se inicia en la misma dirección que la propia matriz. Por lo tanto, &array == &array[0] .

Pero es importante tener en cuenta que los tipos son diferentes:

• El tipo de &array[0] es (en su ejemplo) int* .
• El tipo de &array es int(*)[5] .

La relación entre &array[0] y &array podría ser más fácil si la muestro un poco más "gráficamente" (con los punteros agregados):

+----------+----------+----------+----------+----------+ | array[0] | array[1] | array[2] | array[3] | array[4] | +----------+----------+----------+----------+----------+ ^ | &array[0] | &array

Sin embargo, las cosas son diferentes con los punteros. El puntero pArray está apuntando a alguna memoria, el valor de pArray es la ubicación de esa memoria. Esto es lo que obtienes cuando usas pArray . También es lo mismo que &pArray[0] .

Cuando usas &pArray obtienes un puntero al puntero . Es decir, se obtiene la ubicación (dirección) de la variable pArray . Su tipo es int** .

Algo gráfico con el puntero pArray sería algo como esto

+--------+ +-----------+-----------+-----------+-----------+-----------+-----+ | pArray | ----> | pArray[0] | pArray[1] | pArray[2] | pArray[3] | pArray[4] | ... | +--------+ +-----------+-----------+-----------+-----------+-----------+-----+ ^ ^ | | &pArray &pArray[0]

_{[Tenga en cuenta que ... al final de la "matriz", eso se debe a que los punteros no retienen información sobre la memoria a la que apunta. Un puntero solo apunta a una ubicación específica, el "primer" elemento de la "matriz". Tratar la memoria como una "matriz" depende del programador.]}

Answer 2

Una matriz de X tiene que comportarse como un puntero a una lista contigua de X en la memoria como un puntero. Sin embargo, en ninguna parte se escribe donde la memoria que almacena esos datos debe ser su propia dirección y escritura. En el caso de un puntero explícito, hay una nueva asignación para esta dirección (en este caso, la pila); sin embargo, para una matriz, en la pila, el compilador ya sabe dónde están los contenidos, por lo que no se necesita una nueva asignación.

Como consecuencia, no es seguro tratarlo como un puntero, sin indexación. p.ej:

pArray = nullptr; // This is a memory leak, unless a copy is taken, but otherwise fine.
array = nullptr; // This is will make the compiler upset