Ponteiros e Referências

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 13 de 104.

Agora que você entende a memória da pilha e do heap, vamos explorar as ferramentas que permitem trabalhar diretamente com locais de memória: ponteiros e referências.

Um ponteiro armazena o endereço de memória de outra variável. Você o declara com * e obtém um endereço usando &.

int value = 42;
int* ptr = &value;    // ptr armazena o endereço de value

std::cout << ptr;     // Imprime o endereço de memória
std::cout << *ptr;    // Desreferencia: imprime 42

Uma referência é um alias para uma variável existente. Depois de vinculada, ela sempre se refere a essa variável. Você a declara com &.

int value = 42;
int& ref = value;     // ref é um alias para value

ref = 100;            // Altera value para 100
std::cout << value;   // Imprime 100

Principais diferenças:

Ponteiros	Referências
Podem ser nulos	Devem ser inicializadas
Podem ser reatribuídos	Não podem ser religadas
Use `*` para acessar o valor	Acesse o valor diretamente
Podem apontar para nada	Sempre válidas

Ambos são essenciais para passar objetos para funções com eficiência, sem fazer cópias, e para trabalhar com memória alocada no heap. As referências são mais seguras e simples, enquanto os ponteiros oferecem mais flexibilidade quando você precisa reatribuir ou verificar se há um valor nulo.

Desafio

Fácil

Vamos criar um sistema simples de manipulação de valores que demonstra como ponteiros e referências funcionam de maneira diferente ao modificar dados.

Você criará dois arquivos para organizar seu código:

ValueOps.h: defina três funções que modificam valores inteiros de maneiras diferentes:
- doubleByPointer(int* ptr): recebe um ponteiro e dobra o valor para o qual ele aponta
- tripleByReference(int& ref): recebe uma referência e triplica o valor
- swapValues(int* a, int* b): recebe dois ponteiros e troca os valores para os quais eles apontam
main.cpp: leia dois inteiros da entrada e demonstre ponteiros e referências:
- Imprima os valores originais: "Original: <first> <second>"
- Use doubleByPointer no primeiro valor e, em seguida, imprima: "After double: <first>"
- Use tripleByReference no segundo valor e, em seguida, imprima: "After triple: <second>"
- Use swapValues para trocar os dois valores e, em seguida, imprima: "After swap: <first> <second>"

Ao chamar funções com ponteiros, lembre-se de usar o operador de endereço (&) para passar o endereço da variável. As referências funcionam de maneira mais natural: basta passar a variável diretamente.

Inclua seu arquivo de cabeçalho em main.cpp usando #include "ValueOps.h".

Experimente você mesmo

#include <iostream>
#include "ValueOps.h"
using namespace std;

int main() {
    // Leia dois inteiros da entrada
    int first, second;
    cin >> first;
    cin >> second;
    
    // Imprima os valores originais
    cout << "Original: " << first << " " << second << endl;
    
    // TODO: Use doubleByPointer no primeiro valor (passe o endereço usando &)
    
    // TODO: Imprima após dobrar
    
    // TODO: Use tripleByReference no segundo valor (passe a variável diretamente)
    
    // TODO: Imprima após triplicar
    
    // TODO: Use swapValues para trocar ambos os valores (passe os endereços usando &)
    
    // TODO: Imprima após a troca
    
    return 0;
}