int * i; o int * i; o int * i; [cerrado]

¿Cuál es tu método favorito para declarar un puntero?

int* i;

o

int *i;

o

int * i;

o

int*i;

Por favor explique por qué.

ver también: http://www.stroustrup.com/bs_faq2.html#whitespace

Si tú escribes:

int* i, j, k;

sugieres engañosamente que todo i, j y k son punteros a int.

Así que sostengo que es superior anexar * al nombre de la variable.

Prefiero int* iporque itiene el tipo "puntero a un int", y creo que esto lo hace uniforme con el sistema de tipos. Por supuesto, el comportamiento conocido entra en juego cuando intento definir múltiples punteros en una línea (es decir, el asterisco debe colocarse antes de cada nombre de variable para declarar un puntero), pero simplemente no declaro punteros de esta manera. Además, creo que es un defecto grave en los lenguajes de estilo C.

Para C, donde no tenemos un fuerte enfoque en los tipos, prefiero:

int *i;

Porque tiene un énfasis en el int, no el puntero. ¿Cuál es el int? *ies el int.

Lo he preferido int* ipor años. Sin embargo, hay un fuerte argumento para int *iporque cuando se usa el estilo anterior, aún debe recordar la regla de declaración múltiple:

int* a, *b; // not int* a, b;

Como debes recordar esta regla, no obtienes ninguna de forma explícita, pero tampoco diría que es más compleja. Evitar múltiples declaraciones en una línea es solo otra forma de decir que recuerda esta regla. La diferencia entre los dos estilos es discutible.

Sin embargo, incluso cuando lo uso, se siente un poco tonto fingir que la sintaxis de declaración C funciona de otra manera, colocando el asterisco al lado del tipo en lugar de la variable a la que está sintácticamente vinculado.

Yo no creo en que uno hace hincapié en el tipo de puntero (para i) mientras que el otro hace hincapié en el tipo int (para *i), pero que puede ser que después de 15 años de uso C y C ++, sólo es cuando miro a ella, sin tener que pensarlo, algo que la mayoría de los principiantes que hacen esta pregunta aún no pueden hacer.

Además, incluso dada mi preferencia, no me resulta incómodo leer / escribir código en el otro estilo. Consistencia, bla bla bla.

No hay necesidad de mencionarlo int * i.

Prefiero la primera. Se vuelve natural ya que ser un puntero es parte del tipo.

Como uso C #, maneja los tipos de una manera más intuitiva que C, por lo que no hay problema para declarar varios punteros en la misma declaración:

int* a, b, c; // three pointers

Prefiero int* i(estilo C ++).
Evito declarar múltiples variables en una declaración debido a la ambigüedad visual resultante ( int* i, j).

Consulte también las Preguntas frecuentes sobre el estilo y la técnica C ++ de Bjarne Stroustrup para conocer los fundamentos.

Si desea declarar múltiples variables pero no quiere repetir el asterisco:

template <typename T>
struct pointer_to
{
    typedef T* type;
};

pointer_to<int>::type p1, p2, p3;

(Como puede ver dentro de la plantilla de estructura, prefiero el int* i estilo).

Y aquí hay una solución más general:

template <typename T>
struct identity
{
    typedef T type;
};

identity<int*>::type p1, p2, p3;

Éste funciona con cualquier "tipo problemático", por ejemplo, matrices y referencias:

identity<int[10]>::type a1, a2, a3;

identity<int&>::type r1(*p1), r2(*p2), r3(*p3);

Yo iría int* i;ya que la primera parte denota el tipo de variable (puntero a int), mientras que la segunda parte denota el nombre ( i). No tendría sentido para mí que el tipo es inty el nombre es *i. Además, me int * i;parece un poco como la multiplicación.

En las declaraciones que uso int * i;, lo lees comoi is a pointer to an integer .

El puntero contribuye tanto al tipo como a la variable, por lo que debe estar en el medio.

Es bueno evitar declarar varias cosas en la misma línea: int * i, j;

De hecho, uso las tres convenciones en circunstancias específicas. A primera vista parezco inconsistente, pero ...

• int * cuando el identificador no está presente, para reforzar visualmente que el nombre no está presente.
• int* intptren typedefsy declaraciones similares para reforzar visualmente que es parte del tipo. De manera similar con las declaraciones de puntero de función:(int* (*foo)(int))
• int *identifiery class &identifieren los parámetros de la función para reforzar visualmente que el parámetro es potencialmente un parámetro llamado "fuera".
• const int * const * constcada vez que uso calificadores cv .
• int * foo; en declaraciones locales.

Supongo que soy algo visualmente orientado.

No hay tipos de puntero en C! Entonces, "int *" no significa nada. El asterisco siempre está ligado al elemento escrito correctamente, pertenece al elemento correcto. "* i" es un int. Y debido a que * i es un int, se deduce que soy un puntero a int. Esa es la lógica detrás de esto y es por eso que "int * i" es la única solución posible. Todo lo demás es una ilusión (que el compilador corrige automáticamente en la mayoría de los casos). En C ++ y C # eso es algo diferente. Pero para C solo hay una biblia: "Dennis M. Ritchie: El lenguaje de programación C". Dennis (¡RIP!) Lo escribió: "int * i". No hay necesidad de cuestionar esto.

Lo uso int *iporque es más fácil ver que es un puntero, aunque no creo que sea realmente importante.