Para entender realmente por que os ponteiros são importantes, você precisa entender a diferença entre a alocação de heap e a alocação de pilha.
O seguinte é um exemplo de uma alocação de pilha:
struct Foo {
int bar, baz
};
void foo(void) {
struct Foo f;
}
Os objetos alocados na pilha existem apenas durante a execução da função atual. Quando a chamada para foo
sai do escopo, a variável f
.
Um caso em que isso se torna um problema é quando você precisa retornar algo diferente de um tipo integral de uma função (por exemplo, a estrutura Foo do exemplo acima).
Por exemplo, a seguinte função resultaria no chamado "comportamento indefinido".
struct Foo {
int bar, baz
};
struct Foo *foo(void) {
struct Foo f;
return &f;
}
Se você quiser retornar algo como struct Foo *
de uma função, o que realmente precisa é de uma alocação de heap:
struct Foo {
int bar, baz
};
struct Foo *foo(void) {
return malloc(sizeof(struct Foo));
}
A função malloc
aloca um objeto no heap e retorna um ponteiro para esse objeto. Note que o termo "objeto" é usado frouxamente aqui, significando "algo" em vez de objeto no sentido de programação orientada a objeto.
O tempo de vida de objetos alocados em heap é controlado pelo programador. A memória para este objeto será reservada até que o programador a libere, ou seja, chamando free()
ou até que o programa saia.
Editar : não percebi que essa questão é marcada como uma questão do C ++. Os operadores de C ++ new
e new[]
executam a mesma função que malloc
. Os operadores delete
e delete[]
são análogos a free
. Embora new
e delete
devam ser usados exclusivamente para alocar e liberar objetos C ++, o uso de malloc
e free
é perfeitamente legal no código C ++.