Eu sempre asneira como usar const int*, const int * conste int const *corretamente. Existe um conjunto de regras que define o que você pode ou não fazer?

Quero saber tudo o que fazer e o que não fazer em termos de tarefas, passagem para as funções, etc.

Leia de trás para frente (conforme orientado pela Regra no sentido horário / espiral ):

• int* - ponteiro para int
• int const * - ponteiro para const int
• int * const - ponteiro const para int
• int const * const - ponteiro const para const int

Agora o primeiro constpode estar em ambos os lados do tipo, de modo que:

• const int * == int const *
• const int * const == int const * const

Se você quer enlouquecer, pode fazer coisas assim:

• int ** - ponteiro para ponteiro para int
• int ** const - um ponteiro const para um ponteiro para um int
• int * const * - um ponteiro para um ponteiro const para um int
• int const ** - um ponteiro para um ponteiro para uma const int
• int * const * const - um ponteiro const para um ponteiro const para um int
• ...

E para ter certeza de que estamos claros sobre o significado de const:

int a = 5, b = 10, c = 15;

const int* foo;     // pointer to constant int.
foo = &a;           // assignment to where foo points to.

/* dummy statement*/
*foo = 6;           // the value of a can´t get changed through the pointer.

foo = &b;           // the pointer foo can be changed.



int *const bar = &c;  // constant pointer to int 
                      // note, you actually need to set the pointer 
                      // here because you can't change it later ;)

*bar = 16;            // the value of c can be changed through the pointer.    

/* dummy statement*/
bar = &a;             // not possible because bar is a constant pointer.           

fooé um ponteiro variável para um número inteiro constante. Isso permite alterar o que você aponta, mas não o valor que você aponta. Na maioria das vezes isso é visto com seqüências de caracteres em estilo C, nas quais você tem um ponteiro para a const char. Você pode alterar para qual string você aponta, mas não pode alterar o conteúdo dessas strings. Isso é importante quando a própria string está no segmento de dados de um programa e não deve ser alterada.

baré um ponteiro constante ou fixo para um valor que pode ser alterado. Isso é como uma referência sem o açúcar sintático extra. Por esse motivo, geralmente você usaria uma referência na qual usaria um T* constponteiro, a menos que precise permitir NULLponteiros.

Para quem não conhece a Regra no sentido horário / espiral: comece pelo nome da variável, mova no sentido horário (nesse caso, vá para trás) para o próximo ponteiro ou tipo . Repita até a expressão terminar.

Aqui está uma demonstração:

Acho que tudo já foi respondido aqui, mas quero acrescentar que você deve tomar cuidado com o typedefs! Eles não são apenas substituições de texto.

Por exemplo:

typedef char *ASTRING;
const ASTRING astring;

O tipo de astringé char * const, não const char *. Essa é uma das razões pelas quais sempre tento colocar constà direita do tipo e nunca no começo.

Como praticamente todo mundo apontou:

Qual é a diferença entre const X* p, X* const pe const X* const p?

Você precisa ler as declarações do ponteiro da direita para a esquerda.

• const X* p significa "p aponta para um X que é const": o objeto X não pode ser alterado via p.

• X* const p significa "p é um ponteiro const para um X que não é const": você não pode alterar o ponteiro p em si, mas pode alterar o objeto X via p.

• const X* const p significa "p é um ponteiro const para um X que é const": você não pode alterar o ponteiro p, nem o objeto X via p.

1. Referência constante:

   Uma referência a uma variável (aqui int), que é constante. Passamos a variável como referência principalmente, porque as referências são menores em tamanho que o valor real, mas há um efeito colateral e isso ocorre porque é como um alias para a variável real. Podemos alterar acidentalmente a variável principal por meio de nosso acesso total ao alias, portanto, fazemos com que seja constante para evitar esse efeito colateral.

   int var0 = 0;
   const int &ptr1 = var0;
   ptr1 = 8; // Error
   var0 = 6; // OK

2. Ponteiros constantes

   Uma vez que um ponteiro constante aponte para uma variável, ele não poderá apontar para nenhuma outra variável.

   int var1 = 1;
   int var2 = 0;
   
   int *const ptr2 = &var1;
   ptr2 = &var2; // Error

3. Ponteiro para constante

   Um ponteiro através do qual não se pode alterar o valor de uma variável que aponta é conhecido como ponteiro para constante.

   int const * ptr3 = &var2;
   *ptr3 = 4; // Error

4. Ponteiro constante para uma constante

   Um ponteiro constante para uma constante é um ponteiro que não pode alterar o endereço para o qual está apontando e nem o valor mantido nesse endereço.

   int var3 = 0;
   int var4 = 0;
   const int * const ptr4 = &var3;
   *ptr4 = 1;     // Error
    ptr4 = &var4; // Error

A regra geral é que a constpalavra - chave se aplica ao que a precede imediatamente. Exceção, uma partida constse aplica ao que se segue.

• const int*é o mesmo que int const*e significa "ponteiro para constante int" .
• const int* consté o mesmo que int const* conste significa "ponteiro constante para constante int" .

Edit: Para os prós e contras, se esta resposta não for suficiente, você poderia ser mais preciso sobre o que deseja?

Esta pergunta mostra precisamente por que eu gosto de fazer as coisas da maneira que mencionei na minha pergunta : const após o tipo de ID é aceitável?

Em suma, acho que a maneira mais fácil de lembrar a regra é que o "const" vai depois a coisa se aplica a. Portanto, em sua pergunta, "int const *" significa que o int é constante, enquanto "int * const" significaria que o ponteiro é constante.

Se alguém decide colocá-lo bem na frente (por exemplo: "const int *"), como uma exceção especial nesse caso, isso se aplica à coisa que está depois dela.

Muitas pessoas gostam de usar essa exceção especial porque acham que é melhor. Eu não gosto disso, porque é uma exceção e, portanto, confunde as coisas.

Uso Simples de const.

O uso mais simples é declarar uma constante nomeada. Para fazer isso, declara-se uma constante como se fosse uma variável, mas adiciona-a constantes dela. É preciso inicializá-lo imediatamente no construtor, porque, é claro, não é possível definir o valor posteriormente, pois isso o alteraria. Por exemplo:

const int Constant1=96; 

criará uma constante inteira, chamada sem imaginação Constant1, com o valor 96.

Tais constantes são úteis para parâmetros usados ​​no programa, mas não precisam ser alterados após a compilação do programa. Ele tem uma vantagem para os programadores em relação ao #definecomando do pré-processador C, pois ele é entendido e usado pelo próprio compilador, não apenas substituído pelo texto do programa pelo pré-processador antes de chegar ao compilador principal, portanto as mensagens de erro são muito mais úteis.

Também funciona com ponteiros, mas é preciso ter cuidado constpara determinar se o ponteiro ou o que ele aponta é constante ou ambos. Por exemplo:

const int * Constant2 

declara que Constant2é ponteiro variável para um número inteiro constante e:

int const * Constant2

é uma sintaxe alternativa que faz o mesmo, enquanto

int * const Constant3

declara que Constant3é um ponteiro constante para um número inteiro variável e

int const * const Constant4

declara que Constant4é um ponteiro constante para um número inteiro constante. Basicamente, 'const' se aplica ao que estiver à sua esquerda imediata (exceto se não houver nada lá; nesse caso, se aplica ao que estiver à sua direita imediata).

ref: http://duramecho.com/ComputerInformation/WhyHowCppConst.html

Eu tinha a mesma dúvida que você até encontrar este livro do guru do C ++ Scott Meyers. Consulte o terceiro item deste livro, onde ele fala em detalhes sobre o uso const.

Basta seguir este conselho

1. Se a palavra constaparecer à esquerda do asterisco, o que é apontado é constante
2. Se a palavra constaparecer à direita do asterisco, o ponteiro em si é constante
3. Se constaparecer nos dois lados, ambos são constantes

É simples, mas complicado. Por favor, note que podemos trocar o constqualificador com qualquer tipo de dados ( int, char, float, etc.).

Vamos ver os exemplos abaixo.

const int *p==> *pé somente leitura [ pé um ponteiro para um número inteiro constante]

int const *p==> *pé somente leitura [ pé um ponteiro para um número inteiro constante]

int *p const==> Declaração incorreta . O compilador gera um erro de sintaxe.

int *const p==> pé somente leitura [ pé um ponteiro constante para um número inteiro]. Como o ponteiro paqui é somente leitura, a declaração e a definição devem estar no mesmo local.

const int *p const ==> Declaração incorreta . O compilador gera um erro de sintaxe.

const int const *p ==> *pé somente leitura

const int *const p1 ==> *pe psão somente leitura [ pé um ponteiro constante para um número inteiro constante]. Como o ponteiro paqui é somente leitura, a declaração e a definição devem estar no mesmo local.

int const *p const ==> Declaração incorreta . O compilador gera um erro de sintaxe.

int const int *p ==> Declaração incorreta . O compilador gera um erro de sintaxe.

int const const *p ==> *pé somente leitura e é equivalente aint const *p

int const *const p ==> *pe psão somente leitura [ pé um ponteiro constante para um número inteiro constante]. Como o ponteiro paqui é somente leitura, a declaração e a definição devem estar no mesmo local.

Existem muitos outros pontos sutis que cercam a correção const no C ++. Suponho que a pergunta aqui tenha sido simplesmente sobre C, mas darei alguns exemplos relacionados, pois a tag é C ++:

• Você costuma passar argumentos grandes, como cadeias, o TYPE const &que impede que o objeto seja modificado ou copiado. Exemplo:

  TYPE& TYPE::operator=(const TYPE &rhs) { ... return *this; }

  Mas TYPE & constnão tem sentido porque as referências são sempre constantes.

• Você sempre deve rotular métodos de classe que não modificam a classe como const, caso contrário, não poderá chamar o método a partir de uma TYPE const &referência. Exemplo:

  bool TYPE::operator==(const TYPE &rhs) const { ... }

• Existem situações comuns em que o valor de retorno e o método devem ser const. Exemplo:

  const TYPE TYPE::operator+(const TYPE &rhs) const { ... }

  De fato, os métodos const não devem retornar dados de classe interna como uma referência a não-const.

• Como resultado, é necessário criar frequentemente um método const e um não-const usando sobrecarga const. Por exemplo, se você definir T const& operator[] (unsigned i) const;, provavelmente também desejará a versão não const fornecida por:

  inline T& operator[] (unsigned i) { return const_cast<char&>( static_cast<const TYPE&>(*this)[](i) ); }

Além disso, não existem funções const em C, funções que não são membros não podem ser const em C ++, métodos const podem ter efeitos colaterais e o compilador não pode usar funções const para evitar chamadas de função duplicadas. De fato, mesmo uma int const &referência simples pode testemunhar o valor a que se refere ser alterado em outro lugar.

A sintaxe da declaração C e C ++ foi repetidamente descrita como um experimento com falha, pelos designers originais.

Em vez disso, vamos nomear o tipo "ponteiro para Type"; Vou chamá-lo Ptr_:

template< class Type >
using Ptr_ = Type*;

Agora Ptr_<char>é um ponteiro para char.

Ptr_<const char>é um ponteiro para const char.

E const Ptr_<const char>é um constponteiro para const char.

Lá.

Para mim, a posição de, constou seja, se aparece à ESQUERDA ou à DIREITA ou à esquerda e à direita em relação à *ajuda me ajuda a descobrir o significado real.

1. A constpara a ESQUERDA *indica que o objeto apontado pelo ponteiro é um constobjeto.

2. A constà DIREITA de *indica que o ponteiro é um constponteiro.

A tabela a seguir foi retirada do Leitor de Cursos de Laboratório Stanford CS106L Standard C ++ Programming.

Isso aborda principalmente a segunda linha: melhores práticas, atribuições, parâmetros de função etc.

Prática geral. Tente fazer tudo o constque puder. Ou, de outra forma, faça tudo constpara começar e remova exatamente o conjunto mínimo de consts necessário para permitir que o programa funcione. Isso será uma grande ajuda para alcançar a correção constante e ajudará a garantir que erros sutis não sejam introduzidos quando as pessoas tentam atribuir coisas que não deveriam modificar.

Evite const_cast <> como uma praga. Existem um ou dois casos de uso legítimos para isso, mas eles são muito poucos e distantes entre si. Se você estiver tentando mudar um constobjeto, fará muito melhor para encontrar quem o declarou constno primeiro ritmo e conversar sobre o assunto com eles para chegar a um consenso sobre o que deve acontecer.

O que leva muito bem às tarefas. Você pode atribuir a algo apenas se não for const. Se você deseja atribuir algo que seja const, veja acima. Lembre-se de que nas declarações int const *foo;e nas int * const bar;coisas diferentes existem const- outras respostas aqui abordaram esse assunto de maneira admirável, por isso não vou entrar nisso.

Parâmetros da função:

Passe por valor: por exemplo, void func(int param)você não se importa de uma maneira ou de outra no local da chamada. Pode-se argumentar que há casos de uso para declarar a função como void func(int const param)mas que não têm efeito no chamador, apenas na própria função, na medida em que qualquer valor passado não pode ser alterado pela função durante a chamada.

Passe por referência: por exemplo, void func(int &param)agora faz a diferença. Conforme declarado, funcé permitido mudar param, e qualquer site de chamadas deve estar pronto para lidar com as consequências. Mudar a declaração para void func(int const &param)mudar o contrato e garantir que funcagora não pode mudar param, significando que o que é passado é o que será devolvido. Como outros observaram, isso é muito útil para a passagem barata de um objeto grande que você não deseja alterar. Passar uma referência é muito mais barato do que passar um objeto grande por valor.

Passe pelo ponteiro: por exemplo, void func(int *param)e void func(int const *param)Estes dois são praticamente sinônimo com os seus homólogos de referência, com a ressalva de que a função chamada agora precisa verificar se há nullptrmenos algumas outras assegura garantia contratual funcque nunca vai receber um nullptrem param.

Opinião sobre esse tópico. Provar a correção em um caso como esse é terrivelmente difícil, é muito fácil cometer um erro. Portanto, não se arrisque e sempre verifique os parâmetros do ponteiro nullptr. Você economizará dor e sofrimento e será difícil encontrar insetos a longo prazo. E quanto ao custo da verificação, é muito barato e, nos casos em que a análise estática incorporada no compilador pode gerenciá-la, o otimizador o elimina de qualquer maneira. Ative a geração de código de tempo de link para MSVC ou WOPR (eu acho) para o GCC, e você obterá todo o programa, ou seja, mesmo em chamadas de função que cruzam o limite de um módulo de código-fonte.

No final do dia, tudo o que foi dito acima é um argumento muito sólido para sempre preferir referências a ponteiros. Eles são apenas mais seguros o tempo todo.

A const com o int em ambos os lados fará ponteiro para constante int :

const int *ptr=&i;

ou:

int const *ptr=&i;

constafter *fará um ponteiro constante para int :

int *const ptr=&i;

Nesse caso, todos eles são ponteiros para números inteiros constantes , mas nenhum deles é ponteiro constante:

 const int *ptr1=&i, *ptr2=&j;

Nesse caso, todos são ponteiros para um número inteiro constante e ptr2 é um ponteiro constante para um número inteiro constante . Mas ptr1 não é um ponteiro constante:

int const *ptr1=&i, *const ptr2=&j;

• se constestiver à esquerda de *, refere-se ao valor (não importa se é const intou int const)
• se constestiver à direita de *, refere-se ao ponteiro em si
• pode ser ambos ao mesmo tempo

Um ponto importante: const int *p não significa que o valor a que você está se referindo seja constante !! . Isso significa que você não pode alterá-lo através desse ponteiro (ou seja, não é possível atribuir $ * p = ... `). O valor em si pode ser alterado de outras maneiras. Por exemplo

int x = 5;
const int *p = &x;
x = 6; //legal
printf("%d", *p) // prints 6
*p = 7; //error 

Isso deve ser usado principalmente em assinaturas de funções, para garantir que a função não possa alterar acidentalmente os argumentos passados.

Por uma questão de integridade para C, seguindo as outras explicações, não tenho certeza para C ++.

• pp - ponteiro para ponteiro
• p - ponteiro
• dados - a coisa apontada, em exemplos x
• negrito - variável somente leitura

Ponteiro

• p dados - int *p;
• p dados -int const *p;
• p dados -int * const p;
• p dados -int const * const p;

Ponteiro para ponteiro

1. dados pp p - int **pp;
2. dados pp p -int ** const pp;
3. dados pp p -int * const *pp;
4. dados pp p -int const **pp;
5. dados pp p -int * const * const pp;
6. dados pp p -int const ** const pp;
7. dados pp p -int const * const *pp;
8. dados pp p -int const * const * const pp;

// Example 1
int x;
x = 10;
int *p = NULL;
p = &x;
int **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 2
int x;
x = 10;
int *p = NULL;
p = &x;
int ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 3
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 4
int const x = 10; // Definition must happen during declaration
int const * p = NULL;
p = &x;
int const **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 5
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 6
int const x = 10; // Definition must happen during declaration
int const *p = NULL;
p = &x;
int const ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 7
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 8
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

N-níveis de desreferência

Apenas continue, mas que a humanidade excomunde você.

int x = 10;
int *p = &x;
int **pp = &p;
int ***ppp = &pp;
int ****pppp = &ppp;

printf("%d \n", ****pppp);

1. const int*- ponteiro para intobjeto constante .

Você pode alterar o valor do ponteiro; você não pode alterar o valor do intobjeto, o ponteiro aponta para.

2. const int * const- ponteiro constante para intobjeto constante .

Você não pode alterar o valor do ponteiro nem o valor do intobjeto para o qual o ponteiro aponta.

3. int const *- ponteiro para intobjeto constante .

Esta declaração é equivalente a 1. const int*- Você pode alterar o valor do ponteiro, mas não pode alterar o valor do intobjeto, para o qual o ponteiro aponta.

Na verdade, existe uma quarta opção:

4. int * const- ponteiro constante para o intobjeto.

Você pode alterar o valor do objeto para o qual o ponteiro aponta, mas não pode alterar o valor do próprio ponteiro. O ponteiro sempre apontará para o mesmo intobjeto, mas esse valor intpode ser alterado.

Se você deseja determinar um certo tipo de construção C ou C ++, pode usar a Regra no sentido horário / espiral feita por David Anderson; mas não confundir com a regra de Anderson feita por Ross J. Anderson, que é algo bastante distinto.