it-swarm-es.com

int * i; o int * i; o int * i;

¿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

30
lesmana

Si tú escribes:

int* i, j, k;

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

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

76
Randall Schulz

Yo prefiero int* i porque i tiene 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.

62
Tamás Szelei

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

int *i;

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

23
alternative

He preferido int* i durante años. Sin embargo, hay un fuerte argumento para int *i porque al usar el estilo anterior, aún debe recordar la regla de declaración múltiple:

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

Debido a que 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.

No compro en ese enfatiza el tipo de puntero (para i) mientras que el otro enfatiza el tipo int (para *i), pero puede ser que después de 15 años de uso de C y C++, solo es cuando lo miro, sin tener que pensar en es 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 es necesario mencionar siquiera int * i.

7
Roger Pate

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
6
Guffa

Yo 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 Preguntas frecuentes sobre el estilo y la técnica de C++ de Bjarne Stroustrup para ver los fundamentos.

5
Archimedix

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);
4
fredoverflow

Yo iría por int* i; ya que la primera parte denota el tipo de variable (puntero a int), mientras que la segunda parte denota el nombre (i). Para mí no tendría sentido que el tipo sea int y el nombre sea *i. También, int * i; me parece un poco como la multiplicación.

2
Allon Guralnek

En las declaraciones utilizo int * i;, lo lees como i 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;

2
Tamara Wijsman

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* intptr on typedefs y 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 *identifier y class &identifier en los parámetros de la función para reforzar visualmente que el parámetro es potencialmente un parámetro llamado "fuera".
  • const int * const * const siempre que uso c-v calificadores.
  • int * foo; en declaraciones locales.

Supongo que soy algo visualmente orientado.

1
greyfade

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 (R.I.P.!) Lo escribió: "int * i". No hay necesidad de cuestionar esto.

1
Lexi Pim