Ponteiros em C

Cartões · 52

Declaração de ponteiro para inteiro

int *ptr; // Declara um ponteiro para um valor do tipo int

Operador de endereço (&)

int x = 10; int *p = &x; // &x obtém o endereço de memória de x

Desreferenciação / Acesso ao valor (*)

int x = 10; int *p = &x; int val = *p; // *p acessa o valor apontado (10)

Modificação de valor via ponteiro

int x = 5; int *p = &x; *p = 20; // Altera o valor de x para 20

Ponteiro nulo (NULL)

int *p = NULL; // Inicializa o ponteiro de forma segura apontando para nada

Verificação de ponteiro nulo

if (p != NULL) { *p = 10; } // Evita falha de segmentação testando antes do uso

Ponteiro genérico (void*)

void *ptr; int x = 5; ptr = &x; // void* pode apontar para qualquer tipo

Cast de ponteiro genérico

void *ptr = &x; int v = *(int*)ptr; // Converte void* para int* antes de ler

Passagem de parâmetro por referência

void inc(int *n) { (*n)++; } // Altera a variável original fora da função

Chamada de função com passagem por referência

int a = 5; inc(&a); // Passa o endereço de 'a' para ser modificado

Ponteiro duplo (ponteiro para ponteiro)

int x = 10; int *p = &x; int **pp = &p; // pp armazena o endereço de p

Acesso a valor via ponteiro duplo

**pp = 30; // Altera diretamente o valor de x através de duas desreferenciações

Array decaindo para ponteiro

int arr[3] = {1, 2, 3}; int *p = arr; // arr equivale ao endereço de arr[0]

Aritmética de ponteiros: incremento

int arr[3] = {10, 20, 30}; int *p = arr; p++; // p avança para o próximo int (20)

Aritmética de ponteiros: decremento

p--; // p retrocede sizeof(tipo) bytes na memória

Aritmética de ponteiros: soma de inteiro

int *p2 = arr + 2; // Aponta diretamente para o elemento de índice 2

Aritmética de ponteiros: subtração de inteiro

int *p1 = p2 - 1; // Recua uma posição a partir de p2

Diferença entre dois ponteiros

ptrdiff_t diff = p2 - p; // Retorna a quantidade de elementos entre eles

Comparação de ponteiros

if (p1 < p2) { /* p1 aponta para endereço anterior a p2 */ }

Acesso a elemento de array via ponteiro

int val = *(arr + 1); // Equivalente a arr[1]

Notação de índice com ponteiro

int *p = arr; int val = p[2]; // Equivalente a *(p + 2) ou arr[2]

Percorrendo array com ponteiro

for (int *p = arr; p < arr + 5; p++) { printf("%d ", *p); } // Itera na lista

Ponteiro para constante

const int *p = &x; // O valor apontado não pode ser alterado através de p

Ponteiro constante

int * const p = &x; // O endereço que p guarda não pode ser alterado

Ponteiro constante para constante

const int * const p = &x; // Nem o endereço nem o valor podem ser alterados

Ponteiro para char (string literal)

const char *str = "Olá"; // str aponta para o primeiro caractere da string

Percorrendo string com ponteiro

while (*str != '\0') { putchar(*str++); } // Lê char a char até o nulo

Alocação dinâmica com malloc

int *p = malloc(sizeof(int)); // Aloca memória no heap para um int

Liberação de memória com free

free(p); p = NULL; // Libera a memória alocada e zera o ponteiro

Alocação de array com calloc

int *arr = calloc(5, sizeof(int)); // Aloca 5 ints inicializados com zero

Redimensionamento com realloc

int *temp = realloc(arr, 10 * sizeof(int)); // Redimensiona o bloco de memória

Ponteiro para struct

struct Ponto p = {1, 2}; struct Ponto *ptr = &p; // Aponta para a estrutura

Operador seta (->) em struct

ptr->x = 10; // Atalho equivalente a (*ptr).x = 10

Ponteiro para função

void (*funcPtr)(int) = &minhaFunc; // Armazena endereço de execução de função

Chamada via ponteiro para função

(*funcPtr)(42); // Invoca a função referenciada passando 42

Ponteiro para função como parâmetro (callback)

void exec(void (*cb)(void)) { cb(); } // Recebe e executa callback

Array de ponteiros

char *dias[] = {"Seg", "Ter", "Qua"}; // Array contendo ponteiros char*

Ponteiro para array completo

int arr[5]; int (*pArr)[5] = &arr; // Aponta para o array de 5 ints por inteiro

Aritmética com ponteiro para array

pArr++; // Salta um bloco de 5 inteiros (5 * sizeof(int) bytes)

Troca de valores usando ponteiros (swap)

void swap(int *a, int *b) { int t = *a; *a = *b; *b = t; } // Permuta os valores

Tamanho de um ponteiro na arquitetura

size_t sz = sizeof(int*); // Retorna 8 em arquiteturas 64-bit (4 em 32-bit)

Prevenção de ponteiro selvagem (wild pointer)

int *p = NULL; // Inicializar evita que aponte para lixo de memória

Prevenção de ponteiro pendente (dangling pointer)

free(ptr); ptr = NULL; // Evita apontar para endereço já liberado

Array 2D dinâmico usando ponteiro duplo

int **m = malloc(linhas * sizeof(int*)); // Aloca linhas para a matriz

Alocação das colunas de matriz dinâmica

for (int i = 0; i < l; i++) m[i] = malloc(c * sizeof(int)); // Aloca cada linha

Liberação de matriz dinâmica

for(int i=0; i<l; i++) free(m[i]); free(m); // Libera colunas e vetor principal

Ponteiro para ponteiro de struct

No **head_ref = &head; // Útil para alterar a cabeça de lista encadeada

Impressão de endereço de memória

printf("%p\n", (void*)ptr); // %p formata ponteiro em hexadecimal

Modificação indireta em função via ponteiro duplo

void alocar(int **p) { *p = malloc(sizeof(int)); } // Altera endereço original

Ponteiro restrito (keyword restrict)

void soma(int * restrict a, int * restrict b); // Indica ponteiros sem aliasing

Ponteiro volátil (keyword volatile)

volatile int *reg = (int*)0x4000; // Impede otimização de leitura de hardware

Cópia de bloco de memória com ponteiros

memcpy(dest, src, n * sizeof(int)); // Copia n elementos via ponteiros de bytes