¿Por qué las variables de matriz no tienen una dirección?

Gracias a A2A, es una pregunta reflexiva. Bueno, todo depende de los conceptos de enlazador y cargador. Linker es el lugar donde las instrucciones en el código están vinculadas a un tokenizador y código de operación respectivos.

Supongamos que tiene una variable inicializada, digamos

int a [10];

Entonces, probablemente se convierte en 1 y 0 en el archivo ejecutable. Por lo tanto, tendrá un código operativo respetable y un valor de token.

Como dice la definición de matriz, la matriz es solo un tipo similar de colección de elementos.

Consideremos que tiene una matriz declarada con la dirección inicial 2000, entonces la dirección de la cuarta variable es bastante predecible. Solo está incrementando el tamaño de los bytes del tipo de datos. Pero si obtiene toda la dirección cuando se llama a la dirección de la matriz en el código de operación y los tokens en el enlazador continúan aumentando, lo cual no es un buen fenómeno. Y toda esta ambigüedad es la asignación de memoria de tipo Stack. Pero cuando busca sus propias estructuras de datos, obtiene sus respuestas simplificadas.

#include
int main () {
char c [4];
int i;
para (i = 0; i <4; ++ i) {
printf (“Dirección de c [% d] =% x \ n”, i, & c [i]);
printf (“Dirección de c [% d] =% x \ n”, i, & c);
}
devuelve 0;
}

Si a es una matriz, a no apunta a ninguna parte porque a no es un puntero. Dado int a[42]; , a nombra una matriz de 42 objetos int ; no es un puntero a una matriz de 42 objetos int (que sería int (*a)[42]; ).

&x te da la dirección del objeto x ; si x es una variable de tipo matriz, entonces &x le proporciona la dirección de la matriz; por lo menos, esto es consistente con el comportamiento de & para cualquier otro objeto.

Una mejor pregunta sería “¿por qué una matriz (como a ) se descompone en un puntero a su elemento inicial en la mayoría de los casos cuando se usa?” Si bien no sé con certeza por qué el lenguaje fue diseñado de esta manera, hace que la especificación de muchas cosas sea mucho más simple, en particular, la aritmética con una matriz es efectivamente lo mismo que la aritmética con un puntero.

> La variable de matriz almacena la dirección del primer elemento de la matriz

Eso es falso. Las variables de puntero almacenan direcciones. Las variables de matriz no (a menos que sean matrices de punteros)

> cuando imprime la dirección de la variable de matriz, obtiene la dirección de los primeros elementos. ¿Porque?

Esto se debe a que no hay relleno antes del primer elemento de una matriz (igual que antes del primer miembro de una estructura)

#include
typedef struct X {int n; } struct_t;
typedef int array_t [1];

int main ()
{
struct_t s;
printf (“dirección de la estructura% p \ n”, (void *) & s);
printf (“dirección de su primer miembro% p \ n”, (void *) & s.n);
array_t a;
printf (“dirección de la matriz% p \ n”, (void *) & a);
printf (“dirección de su primer elemento% p \ n”, (void *) & a [0]);

struct Y {struct X x [4]; } n;
printf (“dirección de n% p \ n”, (void *) & n);
printf (“dirección del primer miembro del primer elemento del primer miembro de n% p \ n”, (void *) & n.x [0] .n);
}

demo http://coliru.stacked-crooked.co …

PD: Quizás esté confundido por las conversiones de matriz a puntero: si a es una matriz de int, la instrucción int* p = a no lee de ninguna variable. El compilador lo transforma silenciosamente en int* p = &a[0]

Para hacerlo, debe escribir & arr [index].
Echa un vistazo a http://www.google.co.in/url?q=ht… .

Las matrices almacenan el contenido de la matriz, ni más ni menos. Diría que la dirección del primer elemento se debe a la caída del puntero, y cuando una matriz decae, se convierte en un puntero al primer elemento.

Entonces, cuando lo haces: int foo [10], foo nombra un objeto con un tamaño de 10 entradas con una duración de almacenamiento dada y así sucesivamente. No se refiere a una dirección (eso sería un puntero)

Cuando imprime foo, foo decae de una matriz de 10 pulgadas a un puntero a int (hay algunos casos en que esta decadencia no tiene lugar) al primer elemento.

Tienen simplemente que ningún puntero los señala (puede hacer que el puntero los apunte)

Son bloques de memoria secuenciales y la variable de matriz contiene la dirección del primer elemento. Puede obtener la dirección de los elementos posteriores de esa variable

por ejemplo

#include

int main (nulo) {
// tu código va aquí
int a [4] = {5,6,7,8};
int l = 0;
/ * impresión usando array var * /
para (l = 0; l <4; l ++) {
printf (“% d”, y a [l]);
}
printf (“\ n”);

int * p = a;
/ * impresión con puntero * /
para (l = 0; l <4; l ++) {
printf (“% d”, p ++);
}
devuelve 0;
}

pruébalo Ideone.com