"Dirección de" (&) una matriz/dirección de ser ignorada ser gcc?

Question

Soy un asistente de enseñanza de un curso de introducción a la programación, y algunos estudiantes hacen este tipo de error:

char name[20]; 
scanf("%s",&name); 

lo cual no es sorprendente, ya que están aprendiendo ... Lo que es sorprendente es que, además de la advertencia gcc, el código funciona (al menos esta parte). He estado tratando de entender y escribí el siguiente código:

void foo(int *v1, int *v2) { 
    if (v1 == v2) 
    printf("Both pointers are the same\n"); 
    else 
    printf("They are not the same\n"); 
} 

int main() { 
    int test[50]; 
    foo(&test, test); 
    if (&test == test) 
    printf("Both pointers are the same\n"); 
    else 
    printf("They are not the same\n"); 
} 

Compilar y ejecutar:

$ gcc test.c -g 
test.c: In function ‘main’: 
test.c:12: warning: passing argument 1 of ‘foo’ from incompatible pointer type 
test.c:13: warning: comparison of distinct pointer types lacks a cast 
$ ./a.out 
Both pointers are the same 
Both pointers are the same 

Puede alguien explicar por qué no son diferentes?

Sospecho que es porque no puedo obtener la dirección de una matriz (ya que no puedo tener & &x), pero en este caso el código no debería compilarse.

Editar: Sé que una matriz en sí misma es igual a la dirección del primer elemento, pero esto no está relacionado con este problema, creo. Por ejemplo:

int main() { 
    int a[50]; 
    int * p = a; 
    printf("%d %d %d\n", p == a, p == &a[0], &p[0] == a); 
    printf("%d %d %d\n", p == &a, &p == a, &p == &a); 
} 

impresiones:

$ ./a.out 
1 1 1 
1 0 0 

no entiendo por qué la segunda línea comienza con 1.

Answer 1

En su ejemplo, la matriz test es un bloque de 50 ints. Por lo que se ve así:

| int | int | ... | int | 

Cuando se aplica el operador unitario & a una matriz, se obtiene la dirección de la matriz . Al igual que cuando lo aplicas a cualquier otra cosa, realmente. Así &test es un puntero que apunta a ese bloque de 50 ints:

(&test) -----------> | int | int | ... | int | 

Un puntero que apunta a un array de 50 enteros tiene tipo int (*)[50] - ese es el tipo de &test.

Cuando sólo tiene que utilizar el nombre test en cualquier lugar donde no es el operando de cualquiera de las sizeof o unary- & operadores, se evalúa a un puntero a su primer elemento. Por lo que el test que se pasa a foo() se evalúa como un puntero al elemento test[0]:

(test) -----------------\ 
         v 
(&test) -----------> | int | int | ... | int | 

se puede ver que ambos están apuntando a la misma dirección - a pesar de &test está apuntando a todo el conjunto, y test está señalando al primer elemento de la matriz (que solo aparece en los diferentes tipos que tienen esos valores).

Answer 2

En realidad, son diferentes, al menos no tienen el mismo tipo.

Pero en C, la dirección de la matriz es la misma que la dirección del primer elemento de la matriz por lo que "no son diferentes", básicamente apuntan a lo mismo.

Answer 3

Creo que esto es una optimización de gcc. Piénsalo.

• &test apunta a la dirección de test
• test puntos para el primer elemento de test o &test[0]
• [0] es el mismo (en su mayor parte) como *

Así según esto &testpodría ser diferente que test pero gcc optim lo aleja porque no hay ningún propósito de tener un nivel extra de indirección en ese punto.

Answer 4

Si se define como un conjunto

char name[20]; 

name es convertir implícitamente a char*, pero &name es del tipo char (*)[20] (un puntero a una matriz de 20 caracteres). Las direcciones son iguales.

Compruebe la dirección de (&name + 1). Se diferencia del formulario &name por el sizeof(char [20]).

Answer 5

El nombre de una matriz, en la mayoría de los casos, evalúa a la dirección de su elemento inicial. Las dos excepciones son cuando es el operando de sizeof o el único &.

El unario & da la dirección de su argumento. La dirección de una matriz es la misma que la dirección de su elemento inicial, por lo que (void*)&array == (void*)array siempre será verdadero.

array, cuando se convierte en un puntero a su elemento inicial, tiene el tipo T *. El tipo de &array es T (*)[n], donde n es la cantidad de elementos en la matriz. Por lo tanto,

int* p = array;  // Works; p is a pointer to array[0] 
int* q = &array;  // Doesn't work; &array has type int (*)[10] 
int (*r)[10] = &array; // Works; r is a pointer to array