Ponteiros: Como declarar, Inicializar e Usar

Agora que já aprendemos o que são ponteiros e endereços de memória, vamos colocar a mão na massa, criando e usando ponteiros em C++.

Como Declarar Ponteiros em C++: *

Assim como qualquer outro tipo de variável, para usar um ponteiro, precisamos declarar o tipo de dado ponteiro.

E ele é feito da seguinte maneira:

• tipo *nome;

Por exemplo:

• int *number;

Isso quer dizer que criamos um ponteiro (pois colocamos o asterisco na declaração), que vai apontar para um endereço de memória que armazena valores do tipo int.

Cuidado para não confundir: não é porque tem um int escrito que number é um inteiro. É um ponteiro pra um int, ok?

Para evitar confusão, muitos programadores preferem escrever:

• float* value;

Ou seja, não é uma variável do tipo float, é um ponteiro para um float (é float* e não float).
Rode o exemplo de código abaixo:

#include <iostream>
using namespace std;

int main()
{
    int *number;

    cout << number << endl;

    return 0;
}

O resultado é 0, que é o símbolo de NULL ou ponteiro vazio, em C++.
Aliás, é até uma boa prática inicializar com 0 ou NULL, ponteiros.

Vamos aprender como apontar o ponteiro para um local mais específico.

Como inicializar Ponteiros em C++

Bom, vamos lá.
Primeiro, vamos criar e inicializar uma variável do tipo double:

• double pi = 3.14;

Agora, vamos declarar um ponteiro que aponta para uma variável do tipo double:

• double *pointer;

Para inicializar um ponteiro precisamos fornecer um endereço de memória.
Que tal o endereço de memória da variável pi?
Ele é obtido assim: &pi

Então, declarando e inicializando o ponteiro:

• double *pointer = π

Prontinho, nosso ponteiro aponta pra uma variável.

Vejam o resultado do código:

#include <iostream>
using namespace std;

int main()
{
    double pi = 3.14;
    double *pointer = &pi;

    cout << "Valor da variavel pi   : " << pi << endl;
    cout << "Endereço da variavel pi: " << pointer << endl;

    return 0;
}

Conteúdo de um ponteiro: *pointer

Dizemos que a variável pi referencia diretamente o valor 3.14

Já a variável pointer referencia indiretamente o valor 3.14, pois aponta para o local que ele está armazenado.

Se usarmos a variável pointer, estamos trabalhando com endereço de memória.

Para lidar com o valor que está armazenado naquele endereço, usamos: *pointer

Ou seja, um asterisco antes do nome do ponteiro.

Veja:

#include <iostream>
using namespace std;

int main()
{
    double pi = 3.14;
    double *pointer;
    pointer = &pi;

    cout << "Valor da variavel pi   : " << *pointer << endl;
    cout << "Endereço da variavel pi: " << pointer << endl;

    return 0;
}

Ou seja, tanto faz fazer isso:

cout << pi;

Ou isso:

cout << *pointer;

É a mesma coisa, pois: pointer = &pi

Ou seja, dá no mesmo, pois o ponteiro aponta pra variável.

Como usar ponteiros em C++

E qual o propósito disso?

Simples: podemos também alterar o valor das variáveis, através de seus ponteiros.

Veja no exemplo abaixo, inicialmente a variável tem valor 1.

Em seguida, através de um ponteiro que aponta para ela, alteramos para valor 2:

#include <iostream>
using namespace std;

int main()
{
    int number = 1;
    int *pointer;
    pointer = &number;

    cout <<"Valor inicial de number: " << number << endl;
    *pointer = 2;
    cout <<"Novo valor de number   : " << number << endl;

    return 0;
}

No exemplo anterior, tanto faz trabalhar com 'number' diretamente ou com *pointer.

O asterisco, nesse caso, é chamado de operador indireto.

No exemplo abaixo, fazemos com que um mesmo ponteiro aponte (em momentos diferentes), para variáveis diferentes e altere seus valores:

#include <iostream>
using namespace std;

int main()
{
    int a=1, b=1, c=1;
    int *pointer;

    cout <<"a+b+c: " << (a+b+c) << endl;
    cout <<"Incrementando a, b e c"<<endl;

    pointer = &a;
    (*pointer)++;

    pointer = &b;
    (*pointer)++;

    pointer = &c;
    (*pointer)++;

    cout <<"a+b+c: " << (a+b+c) << endl;

    return 0;
}

Vejam só, alteramos o valor de 3 variáveis, sem atuar diretamente nelas, apenas com um ponteiro.

Note que se fizermos: *pointer++, vai dar erro, pois o operador ++ tem precedência sobre o asterisco, ou seja, o ++ vai agir antes na variável 'pointer', que o operador indireto *.