ti-enxame.com

int * i; ou int * i; ou int * i;

Qual é o seu método favorito para declarar um ponteiro?

int* i;

ou

int *i;

ou

int * i;

ou

int*i;

Por favor, explique o porquê.

consulte também: http://www.stroustrup.com/bs_faq2.html#whitespace

30
lesmana

Se você escrever:

int* i, j, k;

você sugere enganosamente que todos i, j e k são ponteiros para int.

Portanto, eu afirmo que é superior anexar * ao nome da variável.

76
Randall Schulz

Eu prefiro int* i porque i tem o tipo "ponteiro para um int", e acho que isso o torna uniforme com o sistema de tipos. Obviamente, o comportamento bem conhecido aparece ao tentar definir vários ponteiros em uma linha (a saber, o asterisco precisa ser colocado antes de cada nome de variável para declarar um ponteiro), mas eu simplesmente não declaro ponteiros dessa maneira. Além disso, acho que é um defeito grave nas linguagens do estilo C.

62
Tamás Szelei

Para C, onde não temos um foco forte nos tipos, prefiro:

int *i;

Porque ele tem uma ênfase no int, não no ponteiro. Qual é o int? *i é o int.

23
alternative

Eu preferi int* i por anos. No entanto, há um forte argumento para int *i porque ao usar o estilo anterior, você ainda deve se lembrar da regra de múltiplas declarações:

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

Como você deve se lembrar dessa regra, não ganha nada de forma simples - mas eu também não diria que é mais complexo. Evitar várias declarações em uma linha é apenas outra maneira de dizer que você se lembra dessa regra. A diferença entre os dois estilos é discutível.

Mesmo quando eu o uso, no entanto, parece um pouco tolo fingir que a sintaxe da declaração C funciona de outra maneira, colocando o asterisco ao lado do tipo e não da variável à qual está sintaticamente ligado.

Eu não entro nessa enfatiza o tipo de ponteiro (para i) enquanto o outro enfatiza o tipo int (para *i), mas pode ser que, após 15 anos de uso de C e C++, apenas seja quando olho para ele, sem ter que pensar em é algo que a maioria dos iniciantes que faz essa pergunta ainda não pode fazer.

Além disso, mesmo com a minha preferência, não acho estranho ler/escrever código no outro estilo. Consistência, blá blá blá.

Nem é preciso mencionar int * i.

7
Roger Pate

Eu prefiro o primeiro. É natural que ser um ponteiro faça parte do tipo.

Como eu uso o C #, ele lida com tipos de maneira mais intuitiva que o C, portanto não há problema em declarar vários ponteiros na mesma instrução:

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

Eu prefiro int* i (Estilo C++).
Evito declarar várias variáveis ​​em uma instrução devido à ambiguidade visual resultante (int* i, j).

Veja também Perguntas freqüentes sobre estilo e técnica C++ de Bjarne Stroustrup para justificativas.

5
Archimedix

Se você deseja declarar várias variáveis, mas não deseja repetir o asterisco:

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

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

(Como você pode ver dentro do modelo struct, eu prefiro o int* i estilo.)

E aqui está uma solução mais geral:

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

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

Este funciona com qualquer "tipo problemático", por exemplo, matrizes e referências:

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

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

Eu iria para int* i; desde que a primeira parte denota o tipo de variável (ponteiro para int), enquanto a segunda parte denota o nome (i). Não faria sentido para mim que o tipo seja int e o nome seja *i. Além disso, int * i; parece um pouco com multiplicação para mim.

2
Allon Guralnek

Nas declarações eu uso int * i;, você lê como i is a pointer to an integer.

O ponteiro contribui para o tipo e a variável, portanto deve estar no meio.

É bom evitar declarar várias coisas na mesma linha: int * i, j;

2
Tamara Wijsman

Na verdade, uso as três convenções em circunstâncias específicas. À primeira vista, pareço inconsistente, mas ...

  • int * quando o identificador não estiver presente, para reforçar visualmente que o nome não está presente.
  • int* intptr em typedefs e declarações semelhantes para reforçar visualmente que faz parte do tipo. Da mesma forma com declarações de ponteiro de função: (int* (*foo)(int))
  • int *identifier e class &identifier nos parâmetros de função para reforçar visualmente que o parâmetro é potencialmente o chamado parâmetro "out".
  • const int * const * const sempre que eu uso os qualificadores c-v.
  • int * foo; nas declarações locais.

Acho que tenho alguma orientação visual.

1
greyfade

Não há tipos de ponteiros em C! Então, "int *" não significa nada. O asterisco está sempre vinculado ao elemento escrito à direita, pertence ao elemento à sua direita. "* i" é um int. E por causa de * i é um int, segue-se que i é um ponteiro para int. Essa é a lógica por trás disso e é por isso que "int * i" é a única solução possível. Tudo o resto é uma ilusão (que é automaticamente corrigida pelo compilador na maioria dos casos). Em C++ e C # isso é algo diferente. Mas para C há apenas uma Bíblia: "Dennis M. Ritchie: A linguagem de programação C". Dennis (R.I.P.!) Escreveu: "int * i". Não há necessidade de questionar isso.

1
Lexi Pim