Ponteiros em Funções em C++

Neste tutorial de nossa apostila de C++, vamos aprender como trabalhar com ponteiros em funções.
Antes, vamos relembrar um pouco do que aprendemos na seção de Funções.

Passagem por Valor e Variável de Referência

Rode o seguinte programa, que eleva ao quadrado, um número digitado pelo usuário.
Ele mostra o número digitado, ele ao quadrado e depois o valor original, novamente:

#include <iostream>
using namespace std;

int square(int num)
{
    num = num*num;
    cout << "Quadrado: " << num <<endl;
}

int main()
{
    int num;
    cout <<"Digite um número: ";
    cin >> num;

    cout <<"Numero digitado: " << num << endl;
    square(num);
    cout <<"Valor de num: " << num << endl;

    return 0;
}

Veja que passamos a variável 'num' para a função, e lá dentro ela é elevada ao quadrado. Mostramos esse valor dentro da função, e depois mostramos novamente quando a chamada da função é terminada.

Ela não mudou o valor armazenado em 'num'.
Isso ocorre porque quando passamos uma variável pra uma função, a função faz uma cópia de seu valor. Não vai usar a variável diretamente, e sim o seu valor apenas, por isso a variável original não é alterada.

Para dar acesso diretamente à variável, podemos usar as variáveis de referência.
Que é basicamente passar o nome da variável, com o símbolo & na frente, veja como fica:

#include <iostream>
using namespace std;

int square(int &num)
{
    num = num*num;
    cout << "Quadrado: " << num <<endl;
}

int main()
{
    int num;
    cout <<"Digite um número: ";
    cin >> num;

    cout <<"Numero digitado: " << num << endl;
    square(num);
    cout <<"Valor de num: " << num << endl;

    return 0;
}

Agora veja que o valor de 'num' foi alterado dentro da função square():

Isso aconteceu porque usamos a variável de referência &num ao invés de apenas num.

E agora que você já estudou ponteiros e endereços de memória, sabe que ao usar o &, estamos lidando diretamente com endereços de memória. Ou seja, a função agora vai ter acesso ao endereço de memória da variável num e vai alterar esse bloco de memória diretamente.

Como usar Ponteiros em Funções no C++

Outra maneira de alterar o valor de uma variável, passando pra uma função, é usando ponteiros. De fato, é importante saber usar esta técnica, pois ela é bem útil em funções que lidam com Strings e em várias bibliotecas do C++, por exemplo.

Vamos criar uma função, chamada doub(), que vai dobrar o valor que ela receber, usando ponteiros:

#include <iostream>
using namespace std;

int doub(int*);

int main()
{
    int num;
    cout <<"Digite um número: ";
    cin >> num;

    cout <<"Numero digitado: " << num << endl;
    doub(&num);
    cout <<"Valor de num: " << num << endl;

    return 0;
}

int doub(int *ptr_num)
{
    (*ptr_num) = (*ptr_num) * 2;
    cout << "Dobro: " << *ptr_num <<endl;
}

O parâmetro dela é: int*
Ou seja, ela espera um ponteiro do tipo int. Se ela espera um ponteiro, temos que passar como argumento um...endereço de memória! Por isso, fizemos: doub(&num);
Lembrem-se: ponteiro é uma variável que armazena um endereço de memória!

Dentro da função, 'ptr_num'  é um ponteiro. Ponteiro para o endereço de memória da variável 'num' lá da função main().
Queremos dobrar o valor para qual ele aponta. Ora, como se acessa o valor armazenado no local para qual o ponteiro aponta? Usando asterisco: *ptr_num

Por isso, para dobrar o valor da variável 'num', através de ponteiro 'ptr_num' que aponta para ela, basta fazer:
*ptr_num = *ptr_num * 2;

Para não se confundir com os operadores, pode fazer assim que fica mais organizado:
(*ptr_num) = (*ptr_num) * 2;

O poder dos ponteiros

Uma grande vantagem de trabalhar com ponteiros, é que eles podem lidar de maneira mais 'global', digamos assim, com as variáveis para qual apontam.

Por exemplo, note que sempre pedimos um número ao usuário dentro da função main(), e a partir daí mandamos esse valor ou seu endereço para as mais diversas funções.

Usando ponteiros, podemos pegar valores do usuário dentro de uma função, como a getNum(), veja:

#include <iostream>
using namespace std;

void getNum(int *);
int doub(int*);

int main()
{
    int num;
    getNum(&num);
    cout <<"Numero digitado: " << num << endl;

    doub(&num);

    cout <<"Valor de num: " << num << endl;

    return 0;
}

void getNum(int *ptr_num)
{
    cout <<"Digite um número: ";
    cin >> *ptr_num;
}

int doub(int *ptr_num)
{
    (*ptr_num) = (*ptr_num) * 2;
    cout << "Dobro: " << *ptr_num <<endl;
}

Declaramos a variável 'num', e passamos seu endereço para a variável doub(), esse endereço vai ficar armazenado dentro do ponteiro ptr_num.
Agora, queremos alterar o valor de ptr_num, então basta usar: *ptr_num

E prontinho, magicamente, a variável que foi declarada lá na função main() foi alterada dentro da função getNum().

Poderosos, esses ponteiros, não?