C – Inicialización de punteros, posición de asterisco

Posible duplicado:
Declaraciones de puntero en C ++: colocación del asterisco

¿Cuál es la forma más adecuada de colocar un asterisco? ¿Por qué?

1) type* var; 2) type *var; 

No importa en la medida en que declare un solo puntero. Normalmente se escribe como en el segundo ejemplo (en el código que normalmente leo / escribo) pero para el comstackdor es el mismo.

El problema puede surgir si está declarando más de un puntero. Por ejemplo, esto no es declarar dos punteros, sino que declara un puntero y una var de tipo de tipo.

 type* var1, var2; 

Necesitas hacer en su lugar:

 type* var1, *var2; 

Prefiero usar el * por la var siempre.

El puntero es el tipo, y creo que tiene más sentido agrupar la información de tipo:

 int* foo; 

Esto puede generar confusión si se definen varias variables en la misma línea:

 int* foo, bar; // foo will be int*, bar will be int 

La solución a esto es, nunca declarar varias variables en la misma línea. Algo que el Código Completo defiende, de todos modos.

Ambos trabajan. Yo diría que el # 1 es más claro en general , pero engañoso en C y puede conducir a errores, por ejemplo:

 type* var1, var2; // This actually means: type *var1; type var2; 

Así que diría que el # 2 es más idiomático en C y, por lo tanto, recomendado, especialmente si no es el único progtwigdor que trabaja en el código (a menos que, por supuesto, todos estén de acuerdo con un estilo).

Como han señalado otros, ambos funcionan bien y el incorrecto en realidad tiene la ventaja de la economía sintáctica.

De la forma en que lo veo, una statement consiste en un tipo seguido de la variable .

  ; int ii; int* pii; 

Entonces, si quitas la variable , lo que queda es el tipo . Que es int e int * arriba. El comstackdor trata a int * como un tipo interno (que es un puntero a un int ).

C, desafortunadamente, no admite esta syntax a la perfección. Al declarar múltiples variables del mismo tipo, debería poder hacer esto:

  , , ; 

que no se puede con un tipo de puntero:

 int* ii1, ii2, ii3; 

declara ii1 de tipo int * y el rest de tipo int . Para evitar esto, tengo la costumbre de declarar solo una variable por línea.

He oído que argumentaba que técnicamente el * es un modificador de la variable, y esto se evidencia por la necesidad de usar * varias veces en declaraciones de múltiples variables, por ejemplo. int * p, * q, * r;

Sin embargo, me gusta considerarlo como un modificador del tipo base porque eso es lo que aparece en los prototipos. p.ej. función vacía (int *);

.PMCD.

PD. Sé que no he ayudado a su problema 🙂

El segundo modo es correcto. El otro modo no es tan claro para un progtwigdor novato. La variable form int * es usualmente desalentada.

Eso preferiría ser la preferencia de un codificador.

Para mí, declaro punteros por:

 int * var1, var2; 

Donde var1 es un puntero, y var2 no lo es. Si desea declarar múltiples punteros en una línea:

 int * var1, * var2; 

Y por supuesto, usar las otras formas son válidas.

No hay un solo “lugar más apropiado”.

Usualmente es el lugar que usa el rest del código.

Si está escribiendo su propio código desde el principio y puede elegir su propia convención: elija su propia convención y apéguese a ella.

Si elige algo que no sea type * var , se encontrará con situaciones “incómodas”:

 /* write these with another style */ int * var; int const * var; int * restrict var; 

PD. No debería importar, pero normalmente uso type *var;

La semántica de la statement sigue a la semántica de la expresión (específicamente la precedencia del operador) y encuentro que las declaraciones más complejas son más fáciles de leer utilizando el segundo estilo.

Tu puedes pensar en

 int *foo; 

declarando el tipo de la expresión *foo (es decir, el operador de indirección aplicado a foo ) como int lugar de declarar que foo es del tipo int * .

Cualquiera que sea la convención que elija, solo trate de ser consistente.