Ponteiros e alocação

dinâmica
ECT2303 - Linguagem de Programação
Igor Medeiros
Endereço de uma variável
• Toda variável criada em c++ possui um
endereço na memória
Memória
• O endereço de memória de uma variável é
obtido com o operador &

int main() { 1 #0xffffcbcc var

int var = 1;
cout << &var << endl;
}
Ponteiro
• Ponteiros são variáveis que armazenam endereços de memória
• Criamos ponteiros usando o operador * antes do nome da variável
Memória

int main() {
int var = 1;
int *p = &var; //p aponta para um endereço
//de memória que guarda um inteiro 1 #0xffffcbcc var
cout << &var << endl; #0xffffcbcc #0x42ab8901 p

cout << p << endl;

}
Acesso ao conteúdo da variável apontada
• Acessamos o conteúdo apontado por um ponteiro usando o operador *
• Perceba que o operador * é usado na criação do ponteiro e no acesso ao seu
conteúdo.

int main() {
int var = 1;
int *p = &var; //p aponta para um endereço
//de memória que guarda um inteiro
cout << &var << endl;
cout << p << endl;
cout << *p << endl;
}
Pilha de execução
• Quando criamos variáveis locais, é reservado espaço de memória na
pilha de execução (call stack) do programa.
Memória

int main() { void print(int x) {

int a = 1; cout << “x”
int b[2] = {‘H’, ‘i’}; << endl;
print(a) } Pilha de
a, b, x
} execução
Pilha de execução
• Problema: a pilha de execução é pequena Memória

• Em geral menos de 1MB

int main() {
Pilha de
int n[10000000]; n
execução
cout << “Olá Mundo” << endl;
}

• Não podemos armazenar tudo na pilha de execução

Heap
Memória
• Quando um programa lida com grande quantidade de
dados ele deve armazenar esses no heap

• Heap é um espaço de memória muito maior que a Pilha de

pilha de execução a, b
execução
• Adequado para armazenar grande quantidade de dados

int main() {
int a = 1;
int b[2] = {‘H’, ‘i’}; Heap

}
Alocação dinâmica
Memória
• Para armazenar dados no heap, usamos alocação
dinâmica
• Em c++, alocação dinâmica é feita com o operador
new.
Pilha de
• O operador new retorna o endereço de memória que a, b, c
execução
foi alocado no heap
int main() {
int a = 1;
int b[2] = {‘H’, ‘i’}; *c Heap
int *c = new int;
}
Alocação dinâmica
Memória
• Toda variável alocada dinamicamente tem de ser
desalocada antes do término do programa
• A não desalocação causa um problema chamado de
vazamento de memória
• A desalocação é feita com o operador delete; a, b, c
Pilha de
execução

int main() {
int a = 1;
int b[2] = {‘H’, ‘i’};
int *c = new int; Heap
delete c;
}
Alocação dinâmica
• Exemplos
int main() { struct point {
int *a = new int; int x, y;
float *b = new float; };
char *c = new char;
int *v = new int[10]; int main() {
point *pt = new point;
delete a; pt->x = 0;
delete b; pt->y = 0;
delete c;
delete pt;
delete [] v;
}
}
Exercícios
• 1.1) Crie um programa que lê dez inteiros e os armazena em um vetor alocado
dinamicamente.

• 1.2) Escrava uma função que receba o ponteiro para o vetor alocado em 1) e
retorne a soma de seus elementos.
Exercícios
• 2.1) Escreva um programa que cria um tipo Ponto com coordenadas x e y reais.

• 2.2) Aloque dinamicamente duas variáveis do tipo Ponto e atribua os valores

(1,1), (2,2) aos campos x e y das variáveis criadas.

• 2.3) Crie uma função distancia que recebe dois ponteiros do tipo Ponto e
retornam a distância entre os pontos referenciados pelos parâmetros recebidos.