Esta nota demonstra um exemplo básico de como declarar e utilizar [[Ponteiros]] na [[Linguagem de programação C|linguagem de programação C]]. Ponteiros são fundamentais em C para manipulação direta de memória, passagem de argumentos por referência e construção de estruturas de dados complexas.
# Declaração e Desreferenciação de um Ponteiro
Em C, um ponteiro é uma variável que armazena o endereço de memória de outra variável.
```c
#include <stdio.h> // Inclui a biblioteca padrão de entrada e saída
int main(void) {
int n = 50; // Declara uma variável inteira 'n' e atribui o valor 50.
// Declara um ponteiro para um inteiro.
// 'int *p' significa que 'p' é um ponteiro que aponta para um valor do tipo 'int'.
// '&n' é o operador "endereço de", que retorna o endereço de memória da variável 'n'.
int *p = &n;
// Imprime o valor para o qual o ponteiro 'p' aponta.
// '*p' é o operador "desreferência", que acessa o valor armazenado no endereço para o qual 'p' aponta.
printf("O valor de n (acessado via ponteiro): %i\n", *p); // Saída: O valor de n (acessado via ponteiro): 50
// Imprime o endereço de memória da variável 'n'.
printf("O endereço de memória de n: %p\n", &n); // Saída: (um endereço hexadecimal, ex: 0x7ffee5f01234)
// Imprime o valor do ponteiro 'p', que é o endereço de memória de 'n'.
printf("O valor do ponteiro p (o endereço de n): %p\n", p); // Saída: (o mesmo endereço hexadecimal de n)
}
```
# Alterando o Valor Através de um Ponteiro
É possível modificar o valor da variável original usando o ponteiro que aponta para ela.
```c
#include <stdio.h>
int main(void) {
int x = 10;
int *ptr_x = &x; // ptr_x aponta para o endereço de x
printf("Valor original de x: %i\n", x); // Saída: 10
*ptr_x = 20; // Altera o valor no endereço para o qual ptr_x aponta (ou seja, altera x)
printf("Novo valor de x (via ponteiro): %i\n", x); // Saída: 20
printf("Novo valor de x (acessado via ponteiro): %i\n", *ptr_x); // Saída: 20
}
```
# Ponteiros e Arrays
Em C, o nome de um array pode ser tratado como um ponteiro para o seu primeiro elemento. Isso é fundamental para entender a [[Aritmética de ponteiros]].
```c
#include <stdio.h>
int main(void) {
int arr[] = {10, 20, 30};
int *ptr_arr = arr; // ptr_arr aponta para o primeiro elemento de arr (arr[0])
printf("Primeiro elemento: %i\n", *ptr_arr); // Saída: 10
printf("Segundo elemento (usando aritmética de ponteiros): %i\n", *(ptr_arr + 1)); // Saída: 20
printf("Terceiro elemento (usando aritmética de ponteiros): %i\n", *(ptr_arr + 2)); // Saída: 30
}
```
# Usos Comuns de Ponteiros em C
* **Passagem por Referência**: Permite que funções modifiquem variáveis passadas como argumentos.
* **Alocação Dinâmica de Memória**: Usado com funções como `malloc()`, `calloc()`, `realloc()` e `free()` para gerenciar memória na [[Heap na alocação de memória|heap]].
* **Estruturas de Dados**: Essencial para implementar estruturas como [[Listas linkadas implementadas em C|listas encadeadas]], árvores e grafos.
* **Manipulação de Strings**: Strings em C são arrays de caracteres terminados em nulo, frequentemente manipulados com ponteiros.
## Ver também
- [[Ponteiros]]
- [[Aritmética de ponteiros]]
- [[Linguagem de programação C]]
- [[Alocação de memória]]
- [[Heap na alocação de memória]]
- [[Listas linkadas implementadas em C]]