Colocação do asterisco em declarações de ponteiro

Recentemente, decidi que só preciso aprender C / C ++, e há uma coisa que realmente não entendo sobre ponteiros ou, mais precisamente, sua definição.

Que tal estes exemplos:

1. int* test;
2. int *test;
3. int * test;
4. int* test,test2;
5. int *test,test2;
6. int * test,test2;

Agora, no meu entendimento, os três primeiros casos estão todos fazendo o mesmo: Teste não é um int, mas um indicador para um.

O segundo conjunto de exemplos é um pouco mais complicado. No caso 4, teste e test2 serão ponteiros para um int, enquanto no caso 5, apenas teste é um ponteiro, enquanto test2 é um int "real". E o caso 6? Mesmo que o caso 5?

4, 5 e 6 são a mesma coisa, apenas teste é um indicador. Se você quiser duas dicas, você deve usar:

int *test, *test2;

Ou, ainda melhor (para deixar tudo claro):

int* test;
int* test2;

O espaço em branco ao redor dos asteriscos não tem significado. Todos os três significam a mesma coisa:

int* test;
int *test;
int * test;

O " int *var1, var2" é uma sintaxe maligna que visa confundir as pessoas e deve ser evitada. Ele se expande para:

int *var1;
int var2;

Muitas diretrizes de codificação recomendam que você declare apenas uma variável por linha . Isso evita qualquer confusão do tipo que você tinha antes de fazer esta pergunta. A maioria dos programadores de C ++ com quem trabalhei parecem aderir a isso.

Um pouco à parte, eu sei, mas algo que achei útil é ler as declarações de trás para frente.

int* test;   // test is a pointer to an int

Isso começa a funcionar muito bem, especialmente quando você começa a declarar ponteiros const e fica complicado saber se é o ponteiro que é const ou se é para o que o ponteiro está apontando é const.

int* const test; // test is a const pointer to an int

int const * test; // test is a pointer to a const int ... but many people write this as  
const int * test; // test is a pointer to an int that's const

Use a "Regra da espiral no sentido horário" para ajudar a analisar as declarações C / C ++;

Existem três etapas simples a seguir:

1. Começando com o elemento desconhecido, mova-se em espiral / sentido horário; ao encontrar os seguintes elementos, substitua-os pelas declarações em inglês correspondentes:

   [X]ou []: Tamanho da matriz X de ... ou Tamanho indefinido da matriz de ...

   (type1, type2): função passando type1 e type2 retornando ...

   *: apontador (es) para ...

2. Continue fazendo isso em uma espiral / sentido horário até que todas as fichas tenham sido cobertas.
3. Sempre resolva qualquer coisa entre parênteses primeiro!

Além disso, as declarações devem ser feitas em instruções separadas, quando possível (o que é verdade na grande maioria das vezes).

Como outros mencionaram, 4, 5 e 6 são iguais. Freqüentemente, as pessoas usam esses exemplos para fazer o argumento de que *pertence à variável em vez do tipo. Embora seja uma questão de estilo, há um debate sobre se você deve pensar e escrever desta forma:

int* x; // "x is a pointer to int"

ou assim:

int *x; // "*x is an int"

FWIW Estou no primeiro campo, mas a razão pela qual outros defendem a segunda forma é que ela (principalmente) resolve este problema específico:

int* x,y; // "x is a pointer to int, y is an int"

o que é potencialmente enganoso; em vez disso você escreveria

int *x,y; // it's a little clearer what is going on here

ou se você realmente quer duas dicas,

int *x, *y; // two pointers

Pessoalmente, eu digo que mantenha uma variável por linha, então não importa qual estilo você prefere.

#include <type_traits>

std::add_pointer<int>::type test, test2;

Em 4, 5 e 6, testé sempre um ponteiro e test2não é um ponteiro. O espaço em branco (quase) nunca é significativo em C ++.

Na minha opinião, a resposta é AMBAS, dependendo da situação. Geralmente, IMO, é melhor colocar o asterisco ao lado do nome do ponteiro, em vez do tipo. Compare, por exemplo:

int *pointer1, *pointer2; // Fully consistent, two pointers
int* pointer1, pointer2;  // Inconsistent -- because only the first one is a pointer, the second one is an int variable
// The second case is unexpected, and thus prone to errors

Por que o segundo caso é inconsistente? Porque, por exemplo, int x,y;declara duas variáveis ​​do mesmo tipo, mas o tipo é mencionado apenas uma vez na declaração. Isso cria um precedente e um comportamento esperado. E int* pointer1, pointer2;é inconsistente com isso porque declara pointer1como um ponteiro, mas pointer2é uma variável inteira. Está claramente sujeito a erros e, portanto, deve ser evitado (colocando o asterisco ao lado do nome do ponteiro, em vez do tipo).

No entanto , existem algumas exceções em que você pode não ser capaz de colocar o asterisco ao lado do nome de um objeto (e onde importa onde colocá-lo) sem obter resultados indesejados - por exemplo:

MyClass *volatile MyObjName

void test (const char *const p) // const value pointed to by a const pointer

Finalmente, em alguns casos, pode ser indiscutivelmente mais claro colocar o asterisco ao lado do nome do tipo , por exemplo:

void* ClassName::getItemPtr () {return &item;} // Clear at first sight

A lógica em C é que você declara as variáveis ​​da maneira como as usa. Por exemplo

char *a[100];

diz que *a[42]será a char. E a[42]um ponteiro char. E assim aé uma matriz de ponteiros char.

Isso porque os escritores do compilador original queriam usar o mesmo analisador para expressões e declarações. (Não é uma razão muito sensata para uma escolha de design de idioma)

Eu diria que a convenção inicial era colocar a estrela no lado do nome do ponteiro (lado direito da declaração

• na linguagem de programação c de Dennis M. Ritchie, as estrelas estão no lado direito da declaração.

• olhando o código-fonte do linux em https://github.com/torvalds/linux/blob/master/init/main.c podemos ver que a estrela também está no lado direito.

Você pode seguir as mesmas regras, mas não é um grande problema colocar estrelas no lado das letras. Lembre-se de que a consistência é importante, portanto, sempre, mas a estrela do mesmo lado, independentemente do lado que você escolheu.

O ponteiro é um modificador do tipo. É melhor lê-los da direita para a esquerda para entender melhor como o asterisco modifica o tipo. 'int *' pode ser lido como "ponteiro para int '. Em várias declarações, você deve especificar que cada variável é um ponteiro ou será criada como uma variável padrão.

1,2 e 3) O teste é do tipo (int *). O espaço em branco não importa.

4,5 e 6) O teste é do tipo (int *). Test2 é do tipo int. Novamente, o espaço em branco é irrelevante.

Uma boa regra prática, muitas pessoas parecem compreender esses conceitos por: Em C ++, muito significado semântico é derivado pela ligação à esquerda de palavras-chave ou identificadores.

Considere por exemplo:

int const bla;

O const se aplica à palavra "int". O mesmo acontece com os asteriscos dos ponteiros, eles se aplicam à palavra-chave à esquerda deles. E o nome real da variável? Sim, isso é declarado pelo que sobrou dele.