Ponteiros const e volátil

O const e volátil as palavras-chave alterar como os ponteiros são tratados.O const palavra-chave especifica que o ponteiro não pode ser modificado após a inicialização; o ponteiro está protegido contra modificações daí em diante.

O volatile palavra-chave especifica que o valor associado com o nome que se segue pode ser modificado por ações diferentes no aplicativo do usuário.Portanto, o volatile palavra-chave é útil para declarar os objetos na memória compartilhada que pode ser acessada por vários processos ou áreas de dados globais usadas para comunicação com rotinas de serviço de interrupção.

Quando um nome é declarado como volatile, o compilador recarrega o valor da memória de cada vez que ele é acessado pelo programa.Isso reduz drasticamente as otimizações possíveis.No entanto, quando o estado de um objeto pode ser alteradas inesperadamente, é a única maneira de assegurar um desempenho previsível do programa.

Para declarar o objeto apontado pelo ponteiro como const ou volatile, use uma declaração do formulário:

const char *cpch;
volatile char *vpch;

Para declarar o valor do ponteiro — ou seja, o endereço real armazenado no ponteiro — como const ou volatile, use uma declaração do formulário:

char * const pchc;
char * volatile pchv;

A linguagem C++ impede que as atribuições que permitem a modificação de um objeto ou ponteiro é declarado como const.Tais atribuições removeria as informações que o objeto ou o ponteiro foi declarado com, violando a intenção da declaração original.Considere as seguintes declarações:

const char cch = 'A';
char ch = 'B';

Dadas as declarações anteriores de dois objetos (cch, do tipo char const, e ch, do tipo char), as seguintes declaração/inicializações são válidas:

const char *pch1 = &cch;
const char *const pch4 = &cch;
const char *pch5 = &ch;
char *pch6 = &ch;
char *const pch7 = &ch;
const char *const pch8 = &ch;

As seguintes declaração/inicializações estão incorretas.

char *pch2 = &cch;   // Error
char *const pch3 = &cch;   // Error

A declaração do pch2 declara um ponteiro através do qual um objeto de constante pode ser modificado e, portanto, não permitido.A declaração do pch3 Especifica que o pointer é constante, não o objeto; a declaração não é permitida pelo mesmo motivo o pch2 declaração não é permitida.

As atribuições de oito a seguir mostram a atribuição através de ponteiro e alteração do valor de ponteiro para as declarações anteriores; Por enquanto, suponha que a inicialização foi correta para pch1 por meio de pch8.

*pch1 = 'A';  // Error: object declared const
pch1 = &ch;   // OK: pointer not declared const
*pch2 = 'A';  // OK: normal pointer
pch2 = &ch;   // OK: normal pointer
*pch3 = 'A';  // OK: object not declared const
pch3 = &ch;   // Error: pointer declared const
*pch4 = 'A';  // Error: object declared const
pch4 = &ch;   // Error: pointer declared const

Ponteiros são declaradas como volatile, ou como uma mistura de const e volatile, obedecem às mesmas regras.

Ponteiros para const objetos são freqüentemente usados em declarações de função da seguinte maneira:

errno_t strcpy_s( char *strDestination, size_t numberOfElements, const char *strSource );

A instrução anterior declara uma função, strcpy_s, onde dois dos três argumentos são do ponteiro de tipo para char.Porque os argumentos são passados por referência e não por valor, a função ficaria livre para modificar ambos strDestination e strSource se strSource não foram declarados como const.A declaração do strSource como const garante o chamador que strSource não podem ser alteradas pela função chamada.

Observação
Porque há uma conversão padrão de typename* para consttypename*, ele é válido passar um argumento do tipo char * para strcpy_s.   No entanto, a recíproca não é verdadeira; Nenhuma conversão implícita existe para remover o const o atributo de um objeto ou o ponteiro.

A const o ponteiro de um determinado tipo pode ser atribuído a um ponteiro do mesmo tipo.No entanto, um ponteiro que não é const não pode ser atribuído a uma const ponteiro.O código a seguir mostra as atribuições corretas e incorretas:

// const_pointer.cpp
int *const cpObject = 0;
int *pObject;

int main() {
pObject = cpObject;
cpObject = pObject;   // C3892
}

O exemplo a seguir mostra como declarar um objeto como const, se você tiver um ponteiro para um ponteiro para um objeto.

// const_pointer2.cpp
struct X {
   X(int i) : m_i(i) { }
   int m_i;
};

int main() {
   // correct
   const X cx(10);
   const X * pcx = &cx;
   const X ** ppcx = &pcx;

   // also correct
   X const cx2(20);
   X const * pcx2 = &cx2;
   X const ** ppcx2 = &pcx2;
}

Consulte também

Referência

Ponteiros