int * i; ou int * i; ou int * i; [fechado]

Se você escrever:

int* i, j, k; 

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

Portanto, eu afirmo que “é superior anexar o * à variável nome.

Comentários

• E eu ' d sugiro int * i; é um não-competidor apenas porque parece uma multiplicação à primeira vista.
• +1 porque eu não ' não considerei esse cenário antes.
• " você erroneamente sugere que todos os i, j e k são ponteiros para int. " A menos que ' reescrever C #, onde int* é visto como um tipo e int* i, j declara dois ponteiros. A pergunta pode ser considerada incompleta – depende da linguagem que você ' está usando, quais estilos são razoáveis. Em CI siga int *x, em C # eu faço de outra forma.
• @Joren: Desculpe, não sendo um programador C #, eu simplesmente presumi olhando para o fragmento de código em a questão era C ou C ++.
• Acho perfeitamente razoável supor que seja C ou C ++, a menos que C # seja especificamente mencionado. Não se vêem ponteiros em C # com muita frequência.

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. Claro, o comportamento bem conhecido surge, 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 de estilo C.

Comentários

• Eu também sigo essa convenção. Pelo mesmo motivo.
• Pessoalmente, se eu ' m declarando vários ponteiros em meu código, eu trato isso como um cheiro de código. Eu não ' precisaria de tantos ponteiros; e normalmente eu não ' t. Portanto, o problema de várias declarações em uma única linha nunca surge em nenhum código que eu escrevo: uma declaração por linha.
• O problema com isso é que o tipo não é um " apontador para um int ". C (e C ++) não ' tem um tipo de ponteiro. É um ponteiro para um bloco de memória, do tipo int.
• Eu diria que *i tem um tipo de int.
• @Billy: Se sim, eu ' nunca vi essa confusão em 12 anos tentando entender, analisar e explicar o padrão . " Ponteiro para um int " é um tipo perfeitamente válido em C e C ++.

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

int *i;

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

Comentários

• Bom argumento. Com ponteiros, você pode pense no início como sendo parte do nome. Por exemplo, se você tiver int i = 5, para obter o valor de i, use o nome i. Da mesma forma, se você tiver int *i; *i = 5, para obter o valor, use *i.
• Eu li int * i como: * i é um int. Portanto, i é um ponteiro para int.As declarações de variáveis em C usam expressões de tipo, int e * são apenas operadores. int * i analisa como int (* (i)) e é interpretado como i tem o tipo ponteiro para inteiro. char * p [] analisa como char (* ([] (p))) (porque [] tem precedência maior do que *) e significa: p tem tipo array-of ponteiro-para char.
• Para por esse motivo, acho que eles escolheram escrever * ao lado da variável, porque * é um operador aplicado a ela.
• Parece que também prefiro isso – mantém a definição de tipo mais limpa. Além disso, o que Giorgio escreveu faz sentido para mim também e Dennis escreveu algo semelhante em seu raciocínio.

Há anos que prefiro int* i. No entanto, há um forte argumento para int *i porque 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 desta regra, você não ganha nada com simplicidade – 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 desta regra . A diferença entre os dois estilos é discutível.

Mesmo quando eu o uso, no entanto, parece um pouco bobo fingir que a sintaxe da declaração C funciona de outra forma, colocando o asterisco próximo ao tipo em vez de do que a variável à qual está sintaticamente vinculado.

Não acredito nisso 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 ++, ele apenas é quando eu olho para ele, sem ter que pensar sobre isso⁠ — ⁠someth A maioria dos iniciantes que fazem essa pergunta ainda não consegue.

Além disso, mesmo tendo em vista minha preferência, não acho estranho ler / escrever código no outro estilo. Consistência, bla bla blah.

Não é preciso nem mesmo mencionar int * i.

Prefiro o primeiro. É natural, pois um ponteiro faz parte do tipo.

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

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

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

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

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 de estrutura, Eu prefiro o estilo int* i.)

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 arrays e referências:

Comentários

• omg, c ++ sempre mostra algo novo para mim :). Obrigado!
• OMG, C ++ é horrível! typedef int* int_ptr teria resolvido. Claro, tenho que declarar um novo typedef para diferentes tipos de ponteiros, mas na prática, quantos serão? Oito no máximo?
• @benzado Na prática, você não ' não precisa do typedef ou de qualquer um dos truques sofisticados que demonstrei, porque nenhuma pessoa sã declara múltiplas variáveis em uma linha. Ainda assim, interessante.
• Eu sei, eu estava falando mais sobre a tendência dos programas C ++ de usar recursos de linguagem apenas porque podem.
• @benzado: !!! Já vi isso muitas vezes!

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

Comentários

• A sintaxe de declaração C isn ' t consistente a este respeito, pois a informação do tipo pode facilmente vir depois do identificador: arrays sendo o exemplo mais claro.
• @Roger: Eu sei, mas esta questão era especificamente sobre uma única declaração de variável, e nada mais.
• Acho que ' está lendo um pouco sobre isso. 🙂 Pelo que entendi a pergunta, ' está perguntando sobre qual estilo você usa em todos os lugares.
• @Roger: Você ' provavelmente está certo, mas meu objetivo era responder à pergunta do OP ' s: " Qual é seu método favorito para declarar um ponteiro? ".Obviamente, todos são livres para analisar o problema apresentado na pergunta, e isso é até incentivado aqui. Como alguém que não ' não desenvolve em C / C ++, achei que fazer isso se afastaria muito do meu campo de especialização.

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, por isso deve estar no meio.

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

Não há tipos de ponteiro em C! Portanto, “int * “não significa nada. O asterisco está sempre vinculado ao elemento escrito à direita dele, pertence ao elemento à direita dele.” * i “é um int. E como * 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. Todo o resto é uma ilusão (que é corrigido automaticamente 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 questione isso.

Comentários

• " Não há tipos de ponteiro em C " – De onde você tirou essa ideia? int* é um tipo de ponteiro.

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

• int * quando o identificador não está presente, para reforçar visualmente que o nome não está presente.
• int* intptr em typedef se declarações semelhantes para reforçar visualmente que é parte do tipo. Da mesma forma com as declarações de ponteiros de função: (int* (*foo)(int))
• int *identifier e class &identifier em parâmetros de função para reforçar visualmente que o parâmetro é potencialmente um parâmetro “out”.
• const int * const * const sempre que eu usar cv qualificadores.
• int * foo; em declarações locais.

Acho que sou um tanto visualmente orientado.

Eu uso int *i porque é mais fácil ver que é um ponteiro, embora Eu não acho que isso seja realmente importante.