Ponteiros de desreferenciamento

Portanto, um ponteiro contém um número em que 0 é o primeiro byte (8 bits por byte) no espaço de endereço da memória do processo, 1 é o segundo e assim por diante. Quando você deseja acessar o valor para o qual o ponteiro aponta (o conteúdo armazenado no endereço com aquele índice numérico), você então defere o ponteiro. Você usa uma notação de especificação de linguagem para dizer ao compilador ou interpretador no que você está interessado agora.

Considere em C, dado um ponteiro como p abaixo …

const char* p = "abc";

Quatro bytes com valores numéricos usados ​​para codificar os caracteres ‘a’, ‘b’, ‘c’ e um byte nulo para denotar o fim dos dados textuais. Esses caracteres são armazenados em algum lugar da memória e o endereço numérico desses dados é armazenado na variável p. Se quiser se referir aos caracteres para os quais p aponta, você pode usar:

assert(*p == 'a');   // the first character at address p will be 'a'
assert(p[1] == 'b'); // p[1] actually dereferences a pointer created by adding

// pe 1 vezes o tamanho das coisas para as quais p aponta:
// neste caso eles são char, normalmente 1 byte …
assert (* (p + 1) == ‘b’); // outra notação para p [1]

Você pode fazer coisas assim se tiver alguns dados que podem ser gravados em …

int x = 2;
int* p_x = &x;  // put the address of the x variable into the pointer p_x
*p_x = 4;         // change the memory at the address in p_x to be 4
assert(x == 4); // check x is now 4

Você deve saber no momento da compilação que precisa de uma variável chamada x, e o código pede ao compilador para organizar onde deve ser armazenada. Garantir que o endereço estará disponível até & x. Às vezes, você não sabe quanta memória vai precisar até que seu programa esteja em execução e veja quais dados são lançados nele. Você pode então alocar memória dinamicamente usando novos:

int* p = new int;   // get some memory somewhere...
*p = 10;               // dereference the pointer to the memory, then write a value in
fn(*p);                  // call a function, passing it the value at address p
(*p) += 3;            // change the value, adding 3 to it
delete p;             // release the memory back to the heap allocation library