Como é que o endereço de uma matriz é igual ao seu valor em C?

No bit a seguir, os valores e os endereços dos ponteiros diferem conforme o esperado.

Mas valores e endereços de matriz não!

Como isso pode ser?

Resultado

my_array = 0022FF00
&my_array = 0022FF00
pointer_to_array = 0022FF00
&pointer_to_array = 0022FEFC

#include <stdio.h>

int main()
{
  char my_array[100] = "some cool string";
  printf("my_array = %p\n", my_array);
  printf("&my_array = %p\n", &my_array);

  char *pointer_to_array = my_array;
  printf("pointer_to_array = %p\n", pointer_to_array);
  printf("&pointer_to_array = %p\n", &pointer_to_array);

  printf("Press ENTER to continue...\n");
  getchar();
  return 0;
}

O nome de uma matriz geralmente avaliada como o endereço do primeiro elemento da matriz, de modo que arraye &arraytem o mesmo valor (mas tipos diferentes, de modo que array+1e &array+1vai não ser igual, se a matriz é mais do que um elemento de comprimento).

Existem duas exceções: quando o nome da matriz é um operando sizeofou unário &(endereço de), o nome se refere ao próprio objeto da matriz. Assim, sizeof arrayfornece o tamanho em bytes de toda a matriz, não o tamanho de um ponteiro.

Para uma disposição como definida T array[size], que terá tipo T *. Quando / se você incrementa, você chega ao próximo elemento na matriz.

&arrayavalia para o mesmo endereço, mas, dada a mesma definição, cria um ponteiro do tipo T(*)[size]- ou seja, é um ponteiro para uma matriz, não para um único elemento. Se você incrementar esse ponteiro, ele adicionará o tamanho de toda a matriz, não o tamanho de um único elemento. Por exemplo, com código como este:

char array[16];
printf("%p\t%p", (void*)&array, (void*)(&array+1));

Podemos esperar que o segundo ponteiro seja 16 maior que o primeiro (porque é uma matriz de 16 caracteres). Como% p normalmente converte ponteiros em hexadecimal, pode parecer algo como:

0x12341000    0x12341010

Isso ocorre porque o nome da matriz ( my_array) é diferente de um ponteiro para a matriz. É um alias para o endereço de uma matriz e seu endereço é definido como o endereço da própria matriz.

O ponteiro é uma variável C normal na pilha, no entanto. Assim, você pode pegar o endereço e obter um valor diferente do endereço que ele contém.

Eu escrevi sobre este tópico aqui - por favor, dê uma olhada.

Em C, quando você usa o nome de uma matriz em uma expressão (incluindo a passagem para uma função), a menos que seja o operando do operador address-of ( &) ou do sizeofoperador, ele decai para um ponteiro para o primeiro elemento.

Ou seja, na maioria dos contextos arrayé equivalente &array[0]em tipo e valor.

No seu exemplo, my_arraytem um tipo char[100]que decai para a char*quando você o passa para printf.

&my_arraytem tipo char (*)[100](ponteiro para uma matriz de 100 char). Como é o operando &, esse é um dos casos que my_arraynão decai imediatamente para um ponteiro para seu primeiro elemento.

O ponteiro para a matriz tem o mesmo valor de endereço que um ponteiro para o primeiro elemento da matriz como um objeto de matriz é apenas uma sequência contígua de seus elementos, mas um ponteiro para uma matriz tem um tipo diferente de ponteiro para um elemento de essa matriz. Isso é importante quando você faz aritmética de ponteiro nos dois tipos de ponteiro.

pointer_to_arraytem type char *- inicializado para apontar para o primeiro elemento da matriz, como é o que my_arraydecai na expressão do inicializador - e &pointer_to_array possui type char **(ponteiro para um ponteiro para a char).

Destes: my_array(após decaimento para char*), &my_arraye pointer_to_arraytodos apontam diretamente para a matriz ou o primeiro elemento da matriz e, portanto, têm o mesmo valor de endereço.

A razão pela qual my_arraye o &my_arrayresultado no mesmo endereço pode ser facilmente entendida quando você olha para o layout de memória de uma matriz.

Digamos que você tenha uma matriz de 10 caracteres (em vez dos 100 no seu código).

char my_array[10];

Memória para se my_arrayparece com:

+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
^
|
Address of my_array.

Em C / C ++, uma matriz decai para o ponteiro para o primeiro elemento em uma expressão como

printf("my_array = %p\n", my_array);

Se você examinar onde está o primeiro elemento da matriz, verá que seu endereço é o mesmo que o endereço da matriz:

my_array[0]
|
v
+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
^
|
Address of my_array[0].

Na linguagem de programação B, que foi a predecessora imediata de C, ponteiros e números inteiros eram livremente intercambiáveis. O sistema se comportaria como se toda a memória fosse uma matriz gigante. Cada nome de variável tinha um endereço global ou relativo à pilha associado a ele, para cada nome de variável as únicas coisas que o compilador tinha que acompanhar era se era uma variável global ou local e seu endereço relativo ao primeiro local ou global. variável.

Dada uma declaração global como i;[não havia necessidade de especificar um tipo, uma vez que tudo foi um inteiro / ponteiro] seria processado pelo compilador como: address_of_i = next_global++; memory[address_of_i] = 0;e uma declaração como i++seria processado como: memory[address_of_i] = memory[address_of_i]+1;.

Uma declaração como arr[10];seria processada como address_of_arr = next_global; memory[next_global] = next_global; next_global += 10;. Observe que, assim que a declaração foi processada, o compilador pode esquecer imediatamente de arrser uma matriz . Uma declaração como arr[i]=6;seria processada como memory[memory[address_of_a] + memory[address_of_i]] = 6;. O compilador não se importaria se arrrepresentasse uma matriz e ium número inteiro ou vice-versa. Na verdade, não se importaria se eles fossem matrizes ou dois números inteiros; seria perfeitamente feliz em gerar o código conforme descrito, sem considerar se o comportamento resultante provavelmente seria útil.

Um dos objetivos da linguagem de programação C era ser amplamente compatível com B. Em B, o nome de uma matriz [chamada de "vetor" na terminologia de B] identificava uma variável segurando um ponteiro que foi inicialmente designado para apontar para para o primeiro elemento de uma alocação do tamanho especificado, portanto, se esse nome aparecesse na lista de argumentos de uma função, a função receberia um ponteiro para o vetor. Embora C tenha adicionado tipos de matrizes "reais", cujo nome estava rigidamente associado ao endereço da alocação, em vez de uma variável de ponteiro que apontaria inicialmente para a alocação, tendo as matrizes decompostas em códigos feitos por ponteiros que declararam que uma matriz do tipo C se comporta de maneira idêntica para o código B que declarou um vetor e nunca modificou a variável que contém seu endereço.

Na verdade, &myarraye myarrayambos são o endereço base.

Se você quiser ver a diferença em vez de usar

printf("my_array = %p\n", my_array);
printf("my_array = %p\n", &my_array);

usar

printf("my_array = %s\n", my_array);
printf("my_array = %p\n", my_array);