Colocación del asterisco en declaraciones de punteros

Recientemente decidí que finalmente tengo que aprender C / C ++, y hay una cosa que realmente no entiendo sobre los punteros o, más precisamente, su definición.

¿Qué tal estos ejemplos?

1. int* test;
2. int *test;
3. int * test;
4. int* test,test2;
5. int *test,test2;
6. int * test,test2;

Ahora, a mi entender, los primeros tres casos están haciendo lo mismo: Test no es un int, sino un puntero a uno.

El segundo conjunto de ejemplos es un poco más complicado. En el caso 4, tanto test como test2 serán punteros a un int, mientras que en el caso 5, solo test es un puntero, mientras que test2 es un int "real". ¿Y el caso 6? ¿Igual que en el caso 5?

4, 5 y 6 son lo mismo, solo la prueba es un puntero. Si quieres dos punteros, debes usar:

int *test, *test2;

O, mejor aún (para dejarlo todo claro):

int* test;
int* test2;

Los espacios en blanco alrededor de los asteriscos no tienen importancia. Los tres significan lo mismo:

int* test;
int *test;
int * test;

El " int *var1, var2" es una sintaxis maligna que solo pretende confundir a la gente y debe evitarse. Se expande a:

int *var1;
int var2;

Muchas pautas de codificación recomiendan que solo declare una variable por línea . Esto evita cualquier confusión del tipo que tenía antes de hacer esta pregunta. La mayoría de los programadores de C ++ con los que he trabajado parecen ceñirse a esto.

Un poco al margen, lo sé, pero algo que encontré útil es leer las declaraciones al revés.

int* test;   // test is a pointer to an int

Esto comienza a funcionar muy bien, especialmente cuando comienzas a declarar punteros constantes y se vuelve complicado saber si es el puntero lo que es constante, o si es a lo que apunta el puntero lo que es constante.

int* const test; // test is a const pointer to an int

int const * test; // test is a pointer to a const int ... but many people write this as  
const int * test; // test is a pointer to an int that's const

Utilice la "Regla de la espiral en sentido horario" para ayudar a analizar las declaraciones de C / C ++;

Hay tres sencillos pasos a seguir:

1. Comenzando con el elemento desconocido, muévase en espiral / en el sentido de las agujas del reloj; cuando encuentre los siguientes elementos reemplácelos con las correspondientes declaraciones en inglés:

   [X]o []: tamaño de matriz X de ... o tamaño indefinido de matriz de ...

   (type1, type2): función que pasa type1 y type2 regresando ...

   *: puntero (s) a ...

2. Siga haciendo esto en una dirección en espiral / en el sentido de las agujas del reloj hasta que todas las fichas estén cubiertas.
3. ¡Siempre resuelva todo lo que esté entre paréntesis primero!

Además, las declaraciones deben estar en declaraciones separadas cuando sea posible (lo cual es cierto la gran mayoría de las veces).

Como otros mencionaron, 4, 5 y 6 son iguales. A menudo, la gente usa estos ejemplos para argumentar que *pertenece a la variable en lugar del tipo. Si bien es una cuestión de estilo, existe cierto debate sobre si debe pensar y escribirlo de esta manera:

int* x; // "x is a pointer to int"

o de esta manera:

int *x; // "*x is an int"

FWIW Estoy en el primer campo, pero la razón por la que otros argumentan a favor de la segunda forma es que (en su mayoría) resuelve este problema en particular:

int* x,y; // "x is a pointer to int, y is an int"

que es potencialmente engañoso; en su lugar escribirías

int *x,y; // it's a little clearer what is going on here

o si realmente quieres dos punteros,

int *x, *y; // two pointers

Personalmente, digo que lo mantenga en una variable por línea, entonces no importa qué estilo prefiera.

#include <type_traits>

std::add_pointer<int>::type test, test2;

En 4, 5 y 6, testsiempre es un puntero y test2no es un puntero. El espacio en blanco (casi) nunca es significativo en C ++.

En mi opinión, la respuesta es AMBAS, dependiendo de la situación. Generalmente, en mi opinión, es mejor poner el asterisco al lado del nombre del puntero, en lugar del tipo. Compare, por ejemplo:

int *pointer1, *pointer2; // Fully consistent, two pointers
int* pointer1, pointer2;  // Inconsistent -- because only the first one is a pointer, the second one is an int variable
// The second case is unexpected, and thus prone to errors

¿Por qué el segundo caso es inconsistente? Porque, por ejemplo, int x,y;declara dos variables del mismo tipo pero el tipo se menciona solo una vez en la declaración. Esto crea un precedente y un comportamiento esperado. Y int* pointer1, pointer2;es inconsistente con eso porque se declara pointer1como un puntero, pero pointer2es una variable entera. Claramente propenso a errores y, por lo tanto, debe evitarse (colocando el asterisco al lado del nombre del puntero, en lugar del tipo).

Sin embargo , existen algunas excepciones en las que es posible que no pueda colocar el asterisco junto al nombre de un objeto (y dónde importa dónde lo ponga) sin obtener un resultado no deseado, por ejemplo:

MyClass *volatile MyObjName

void test (const char *const p) // const value pointed to by a const pointer

Finalmente, en algunos casos, podría decirse que sería más claro poner el asterisco al lado del nombre del tipo , por ejemplo:

void* ClassName::getItemPtr () {return &item;} // Clear at first sight

El fundamento de C es que declaras las variables de la forma en que las usas. Por ejemplo

char *a[100];

dice que *a[42]será un char. Y a[42]un puntero de char. Y así aes una matriz de punteros char.

Esto porque los escritores del compilador original querían usar el mismo analizador para expresiones y declaraciones. (No es una razón muy sensata para elegir un diseño de idioma)

Yo diría que la convención inicial era poner la estrella en el lado del nombre del puntero (lado derecho de la declaración

• en el lenguaje de programación c de Dennis M. Ritchie, las estrellas están en el lado derecho de la declaración.

• Al mirar el código fuente de Linux en https://github.com/torvalds/linux/blob/master/init/main.c podemos ver que la estrella también está en el lado derecho.

Puede seguir las mismas reglas, pero no es un gran problema si coloca estrellas en el lado de la letra. Recuerda que la consistencia es importante, por eso siempre pero la estrella del mismo lado independientemente del lado que hayas elegido.

El puntero es un modificador del tipo. Es mejor leerlos de derecha a izquierda para comprender mejor cómo el asterisco modifica el tipo. 'int *' se puede leer como "puntero a int '. En declaraciones múltiples, debe especificar que cada variable es un puntero o se creará como una variable estándar.

1, 2 y 3) La prueba es de tipo (int *). El espacio en blanco no importa.

4, 5 y 6) La prueba es de tipo (int *). Test2 es de tipo int. Nuevamente, el espacio en blanco es intrascendente.

Como regla general, mucha gente parece comprender estos conceptos de la siguiente manera: En C ++, una gran cantidad de significado semántico se deriva de la unión a la izquierda de palabras clave o identificadores.

Toma por ejemplo:

int const bla;

La constante se aplica a la palabra "int". Lo mismo ocurre con los asteriscos de los punteros, se aplican a la palabra clave que queda a la izquierda de ellos. ¿Y el nombre de la variable real? Sí, eso lo declara lo que queda de él.