int * i; ou int * i; ou int * i; [fechadas]

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

Se você escrever:

int* i, j, k;

você sugere enganosamente que todos os itens i, j e k são indicadores de int.

Então, eu afirmo que é superior anexar * ao nome da variável.

Eu prefiro int* iporque item o tipo "ponteiro para um int" e sinto 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 (ou seja, 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.

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

int *i;

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

Eu tenho preferido int* ipor anos. No entanto, há um forte argumento int *iporque, ao usar o estilo anterior, você ainda deve se lembrar da regra de declaração múltipla:

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

Como você deve se lembrar dessa regra, não ganha nada de maneira 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, é 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 compro em que se enfatiza o tipo de ponteiro (para i) enquanto o outro enfatiza o tipo int (para *i), mas que pode ser que depois de 15 anos de C e C ++ uso, ele só é quando eu olhar para ele, sem ter que pensar nisso - 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á.

Não precisa nem mencionar int * i.

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

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

Consulte também as Perguntas frequentes sobre estilo e técnica C ++ de Bjarne Stroustrup para obter razões lógicas.

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* iestilo.)

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

Eu iria 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 é inte o nome é *i. Além disso, int * i;parece um pouco com multiplicação para mim.

Nas declarações que 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;

Na verdade, eu 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, reforçar visualmente que o nome não está presente.
• int* intptrem se typedefdeclaraçõ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 *identifiere class &identifiernos parâmetros de função para reforçar visualmente que o parâmetro é potencialmente o chamado parâmetro "fora".
• const int * const * constsempre que eu uso qualificadores cv .
• int * foo; nas declarações locais.

Acho que tenho alguma orientação visual.

Não há tipos de ponteiros em C! Então, "int *" não significa nada. O asterisco está sempre vinculado ao elemento escrito à sua 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 (RIP!) Escreveu: "int * i". Não há necessidade de questionar isso.

Eu uso int *iporque é mais fácil ver que é um ponteiro, embora eu não ache que seja realmente uma questão.