Ponteiros e referências

Valor vs. endereço

Quando você escreve int b = a; em C, copia o valor de a para b. São duas gavetas diferentes na stack, cada uma com sua própria cópia do número. Alterar uma não afeta a outra.

Quando você passa um objeto em Python (b = a), copia a referência — b e a são etiquetas diferentes para o mesmo objeto no heap. Modificar o objeto via b também é visível por a, porque apontam para o mesmo endereço.

Ponteiros em C são explícitos sobre isso: a sintaxe *p e &x deixa claro que você está lidando com endereços. Em linguagens de alto nível a referência é implícita, o que é mais confortável mas pode surpreender quem não sabe o que acontece por baixo.

Valor vs. referência na prática

Alterne entre os dois modos e experimente modificar variáveis para ver o que muda e o que não muda.

Ponteiros em C

// Ponteiros em C: variáveis que guardam endereços
int x = 42;
int* p = &x;        // & = "endereço de" → p guarda o endereço de x

printf("%p\n", p);    // imprime ex: 0x7ffd3a20  (endereço)
printf("%d\n", *p);   // * = "valor em" → imprime 42
*p = 100;            // escreve via ponteiro → x agora é 100

// Aritmética de ponteiro
int arr[4] = {10, 20, 30, 40};
int* q = arr;        // arr decai para &arr[0]
printf("%d\n", *(q + 2));  // arr[2] = 30 (avança 2 × sizeof(int))

// Ponteiro para ponteiro
int** pp = &p;       // pp aponta para p, que aponta para x
**pp = 200;         // modifica x via dois níveis de indireção

Semântica de referência em Python

// Python: semântica de referência para objetos mutáveis
a = [1, 2, 3]
b = a            // b aponta para o MESMO objeto
b.append(4)
print(a)         // [1, 2, 3, 4] — a viu a mudança!

// Para copiar:
c = a.copy()           // cópia rasa (shallow) — objetos aninhados ainda são refs
import copy
d = copy.deepcopy(a)   // cópia profunda — tudo novo

// Tipos imutáveis (int, str, tuple) têm semântica de valor na prática
x = 42
y = x
y = 99
print(x)         // 42 — y recebeu uma referência ao inteiro 42,
                 // mas y = 99 criou um novo objeto inteiro, não modificou o 42

Ponteiros na prática

Mini projeto: em C, implemente swap(int* a, int* b) que troca o conteúdo de dois inteiros. Teste chamando swap(&x, &y) e confirme que x e y foram realmente trocados. Compare com uma versão errada que recebe int por valor.

Projeto principal: em Python, implemente uma função deep_equal(a, b) que compara dois objetos arbitrariamente aninhados (dicionários com listas de dicionários) e retorna True se os valores são iguais — mesmo que sejam objetos diferentes na memória. Use is para checar identidade e == para checar igualdade. Demonstre a diferença em exemplos concretos.

Desafio extra: em C, implemente uma lista encadeada simples (linked list) usando ponteiros. Adicione funções para inserir no início, remover um elemento por valor e imprimir a lista. Confirme com Valgrind que todos os nós são liberados corretamente ao destruir a lista. Por que arrays contíguos têm melhor cache locality que listas encadeadas?

Teste sua intuição

Onde você encontra isso