Sintaxis del puntero en C: ¿por qué * solo se aplica a la primera variable?

Question

La siguiente declaración en C:

int* a, b; 

declarará a como tipo int* y b como tipo int. Soy muy consciente de esta trampa, pero lo que quiero saber es por qué funciona de esta manera. ¿Por qué no declara también b como int*, como la mayoría de las personas esperaría intuitivamente? En otras palabras, ¿por qué se aplica * al nombre de la variable, en lugar del tipo?

Claro que podría escribir de esta manera a ser más coherente con la forma en que realmente obras:

int *a, b; 

Sin embargo, yo y todos los que he hablado pensar en términos de una es de tipo " puntero a int ", en lugar de a es un puntero a algunos datos y el tipo de esos datos es" int ".

¿Fue simplemente una mala decisión de los diseñadores de C o hay alguna buena razón por la cual se analiza de esta manera? Estoy seguro de que la pregunta ha sido respondida antes, pero parece que no puedo encontrarla usando la búsqueda.

Answer 1

Hay una página web en The Development of the C Language que dice: "La sintaxis de estas declaraciones refleja la observación de que i, * pi y ** ppi producen un tipo int cuando se usan en una expresión". Busque esa frase en la página para encontrar la sección relevante que habla sobre esta pregunta.

Answer 2

Puede haber una razón histórica adicional, pero siempre me he entendido de esta manera:

Una declaración, un tipo.

Si a, b, c, y d deben ser del mismo tipo aquí:

int a, b, c, d; 

Entonces todo en la línea debe un número entero también.

int a, *b, **c, ***d; 

Los 4 números enteros:

1. un
2. * b
3. ** c
4. *** d

Se puede estar relacionado con la precedencia de operadores, también, o puede haber sido en algún momento en el pasado.

Answer 3

El * modifica el nombre de la variable, no el especificador de tipo. Esto se debe principalmente a la forma en que se analiza el *. Tome estas declaraciones:

char* x; 
char *x; 

Esas declaraciones son equivalentes. El operador * necesita estar entre el especificador de tipo y el nombre de la variable (se trata como un operador infijo), pero puede ir a ambos lados del espacio. Teniendo en cuenta esto, la declaración

int* a, b; 

no haría b un puntero, porque no hay * adyacente a la misma. El * solo opera en los objetos a cada lado.

Además, piénselo de esta manera: cuando escribe la declaración int x;, indica que x es un número entero. Si y es un puntero a un número entero, entonces *y es un número entero. Cuando escribe int *y;, indica que *y es un número entero (que es lo que desea). En la declaración char a, *b, ***c;, está indicando que la variable a, el valor desreferenciado de b, y el valor triplemente desreferenciado de c son todos del tipo char. Al declarar las variables de esta forma, el uso del operador de estrella (casi) es coherente con la desreferenciación.

Estoy de acuerdo con que tendría más sentido que sea al revés. Para evitar esta trampa, me convertí en una regla siempre para declarar punteros en una línea por sí mismos.

Answer 4

Las declaraciones C se escribieron de esta manera para que "la declaración espeje use". Es por eso que declarar un arreglo de esta manera:

int a[10]; 

que iban a tener lugar la regla que usted propone, donde es siempre

type identifier, identifier, identifier, ... ; 

... entonces las matrices lógicamente tendría que ser declarado como esto :

int[10] a; 

lo cual está bien, pero no refleja cómo se utiliza a. Tenga en cuenta que esto es válido para las funciones, también - declaramos funciones de la siguiente manera:

void foo(int a, char *b); 

en lugar de

void(int a, char* b) foo; 

En general, los "espejos de declaración de uso" regla significa que sólo tiene que recordar una serie de las reglas de asociatividad, que se aplican a los operadores como *, [] y () cuando usa el valor, y los tokens correspondientes en los declaradores como *, [] y ().

---

Después de pensar un poco más, creo que es también vale la pena señalar que la ortografía "puntero a int" como "int*" es sólo una consecuencia de "espejos de declaración de uso" de todos modos. Si fuera a usar otro estilo de declaración, probablemente tendría más sentido deletrear "puntero a int" como "&int", o algo completamente diferente como "@int".

Answer 5

Porque si la declaración

int* a, b; 

declarara b como un puntero, lo que no tendría forma de declarar

int* a; 
int b; 

en una sola línea.

Por otro lado, se puede hacer

int*a, *b; 

para conseguir lo que desea.

Piénsalo así: la forma en que es ahora sigue siendo la forma más concisa y, sin embargo, única de hacerlo. Eso es lo que C es principalmente acerca :)

Answer 6

supongo que está relacionada con la sintaxis de declaración completa de modificadores de tipo:

int x[20], y; 
int (*fp)(), z; 

En estos ejemplos, se siente mucho más obvio que los modificadores solamente están afectando a una de las declaraciones Una suposición es que una vez que K & R decidió diseñar modificadores de esta manera, se consideró "correcto" que los modificadores solo afectaran a una declaración.

En una nota lateral, recomendaría simplemente limitación a una variable por declaración:

int *x; 
int y; 

Answer 7

sólo puedo adivinar por qué habría que repetir el * para cada nombre de la variable mencionada en una línea para hacer ellos todos los punteros. ¿Tal vez esto se deba a una decisión sobre la coherencia del lenguaje? Permítanme ilustrar esto con un ejemplo:

---

Supongamos que tiene una función foo declara como sigue:

int foo() { ... } 

Supongamos también que desea declarar dos punteros de función para esta función:

int (*fooptr1, fooptr2)(); 
// this doesn't work; and even if it did, what would the syntax possibly 
// look like to initializing them to function foo? 
// int (*fooptr1 = foo, fooptr2 = foo)() ? 

int (*fooptr1)() = foo, (*fooptr2)() = foo; 
// this works. 

En este caso, simplemente tiene que repetir toda la declaración de tipo de b otras variables, y no se puede equivocar porque no hay otra forma de hacerlo (dada la sintaxis de la declaración C tal como está).

---

Ahora, tal vez se pensó, si hay casos en que la declaración de tipo tiene que ser repetido para todas las variables, tal vez esto sólo debería ser el caso general.

(no se olvide que estoy aquí sólo una suposición.)

Answer 8

Considerar la declaración:

int *a[10]; 
int (*b)[10]; 

La primera es una serie de diez punteros a enteros, el segundo es un puntero a una matriz de diez enteros.

Ahora, si el * se adjuntó a la declaración de tipo, no sería sintácticamente válido poner un paréntesis entre ellos. Entonces tendrías que encontrar otra manera de diferenciar entre las dos formas.