Exerccios

1) Crie uma funo que recebe os coeficientes

de uma funo do 2o. grau e retorna as
razes sem usar vetor.
Alocao Dinmica
2) Faa um programa que acha o maior e o
menor inteiro dentro de um vetor de 10 Introduo Computao
inteiros, calcule a soma e imprime a soma. Prof. Denis Wolf
Obs: usar apenas as vriaveis a seguir:
int v[10], i, *maior, *menor;

Alocao de memria Alocao dinmica de memria

Uso da memria:
uso de variveis globais (e estticas):
O espao reservado para uma varivel global existe
enquanto o programa estiver sendo executado.
uso de variveis locais:
Neste caso, o espao existe apenas enquanto a funo
que declarou a varivel est sendo executada, sendo
liberado para outros usos quando a execuo da
funo termina. Assim, a funo que chama no pode
fazer referncia ao espao local da funo chamada.
reservar memria requisitando ao sistema, em
tempo de execuo, um espao de um
determinado tamanho.
A linguagem C oferece meios de requisitarmos
espaos de memria em tempo de execuo.
O espao alocado dinamicamente permanece
reservado at que explicitamente seja liberado
pelo programa.
Por isso, podemos alocar dinamicamente um espao
de memria numa funo e acess-lo em outra.
A partir do momento que liberarmos o espao,
ele estar disponibilizado para outros usos e no
podemos mais acess-lo.
Se o programa no liberar um espao alocado, este
ser automaticamente liberado quando a execuo do
programa terminar.

3 4

Alocao da Memria Principal Alocao da Memria Principal

Para executar um
determinado programa, o
S.O. carrega na memria o
cdigo do programa, em
linguagem de mquina.
Cdigo do
Cada vez que uma funo Cdigo do
chamada, o S.O. reserva o
Programa espao necessrio para as Programa
variveis locais da funo. Este
Variveis espao pertence pilha de Variveis
execuo e, quando a funo
Memria Livre (Heap)

Alm disso, o S.O. reserva Globais e Estticas termina, liberado. Globais e Estticas
os espaos necessrios para

A memria no ocupada pela
armazenar as variveis Memria Alocada pilha de execuo pode ser Memria Alocada
globais (e estticas) do
Memria Livre

Dinamicamente requisitada dinamicamente. Se Dinamicamente

programa a pilha tentar crescer mais do
O restante da memria livre que o espao disponvel
utilizado pelas variveis existente, dizemos que ela
locais e pelas variveis estourou e o programa
alocadas dinamicamente. abortado com erro.
Pilha Pilha
5 6

1
 Alocao da Memria Principal
Exemplos:
Cdigo que aloca 1000 bytes de memria livre:
char *p;
p = malloc(1000);
Cdigo que aloca espao para 50 inteiros:
int *p;
p = malloc(50*sizeof(int));
Obs.: O operador sizeof() retorna o nmero de bytes de
um inteiro.
7 8
Funes para Alocar e Liberar memria
A funo malloc usada para alocar espao para
armazenarmos valores de qualquer tipo. Por este
motivo, malloc retorna um ponteiro genrico, para um
tipo qualquer, representado por void* , que pode ser
convertido automaticamente pela linguagem para o
tipo apropriado na atribuio.
No entanto, comum fazermos a converso
explicitamente, utilizando o operador de molde de tipo
(cast).
Ento:
v = (int *) malloc(10*sizeof(int));
9 10
Alocao Dinmica de Memria
As funes calloc e malloc permitem alocar
blocos de memria em tempo de execuo.
Prottipo da funo malloc:
void * malloc(size_t n);
/* retorna um ponteiro void para n bytes de
memria no iniciados. Se no h memria
disponvel malloc retorna NULL */
11
Funes para Alocar e Liberar memria
Funo bsica para alocar memria malloc()
int *vet;
vet = malloc(10*4);
Aps estes comandos, se a alocao for bem sucedida, vet
armazenar o endereo inicial de uma rea contnua de
memria suficiente para armazenar 10 valores inteiros.
Desta forma, consideramos que um inteiro ocupa 4 bytes.
Para ficarmos independentes de compiladores e mquinas,
usamos o operador sizeof( )
v = malloc(10*sizeof(int));
Funes para Alocar e Liberar memria
Se no houver espao livre suficiente para realizar a alocao, a
funo retorna um endereo nulo (representado pelo smbolo
NULL, definido em stdlib.h).
Podemos tratar o erro na alocao do programa simplesmente
verificando o valor de retorno da funo malloc
Ex: imprimindo mensagem e abortando o programa com a funo
exit, tambm definida na stdlib.
v = (int*) malloc(10*sizeof(int));
if (v == NULL) {
printf("Memoria insuficiente.\n");
exit(1); /* aborta o programa e retorna 1 para o sist. operacional */
}
Alocao Dinmica de Memria
As funes calloc e malloc permitem alocar
blocos de memria em tempo de execuo.
Prottipo da funo calloc:
void * calloc(size_t n, size_t size);
/* calloc retorna um ponteiro para um array com
n elementos de tamanho size cada um ou NULL se
no houver memria disponvel. Os elementos
so iniciados em zero */
12
2
 Alocao Dinmica de Memria
O ponteiro retornado por tanto pela funo malloc
quanto pela calloc devem ser convertido para o tipo de
ponteiro que invoca a funo
int *pi = (int *) malloc (n*sizeof(int));
/* aloca espao para um inteiro */
int *ai = (int *) calloc (n, sizeof(int));
/* aloca espao para um array de n inteiros */
Alocao Dinmica
toda memria no mais utilizada deve ser liberada
atravs da funo free(): VETORES E MATRIZES
free(ai); /* libera todo o array */
free(pi); /* libera o inteiro alocado */

13 14

Vetores e alocao dinmica Vetores e alocao dinmica

A forma mais simples de estruturarmos um O acesso a cada elemento do vetor
conjunto de dados por meio de vetores. feito atravs de uma indexao da
Definimos um vetor em C da seguinte forma: varivel v .
int v[10]; Em C, a indexao de um vetor varia de
144
Esta declarao diz que: zero a n-1, onde n representa a
v um vetor de inteiros dimensionado com 10 dimenso do vetor.
elementos, isto , reservamos um espao de memria v[0] acessa o primeiro elemento de v
contnuo para armazenar 10 valores inteiros. v[1] acessa o segundo elemento de v
Assim, se cada int ocupa 4 bytes, a declarao reserva ...
um espao de memria de 40 bytes 104 v mas v[10] invade a memria

15 16

Relao entre Vetores e Ponteiros Vetores e alocao dinmica

#include <stdio.h> Suponha que desejamos armazenar uma
/* Incrementa elementos de um vetor */ quantidade n de valores inteiros,porm essa
void incr_vetor (int *v , int tam) {
quantidade somente conhecida pelo usurio.
int i;
for (i = 0; i < tam; i++) A sada do programa 2 4 6, Como proceder a reserva de memria necessria
v[i]++; pois os elementos do vetor para os dados?
} sero incrementados dentro Se declararmos um vetor grande podemos incorrer
int main () { da funo. em dois riscos:
int a[ ] = {1, 3, 5}; ainda assim ser pequeno o bastante para no caber os dados
incr_vetor(a, 3); ou grande demais e desperdiar memria
printf("%d %d %d\n", a[0], a[1], a[2]); Solicitar a memria necessria assim que a
return 0; quantidade for conhecida
}

17 18

3
 Vetores e alocao dinmica Alocao dinmica de matrizes
#include <stdio.h>
#include <stdlib.h> A alocao dinmica de memria para
int main () {
int *v, n, i;
matrizes realizada da mesma forma que para
printf("Qual o tamanho do vetor que deseja:");
scanf("%d", &n);
vetores, com a diferena que teremos um
v = (int *) calloc(n, sizeof(int)); /* aloca um vetor de n posies inteiras */ ponteiro apontando para outro ponteiro que
for (i =0; i<n; i++) {
printf(Informe o %d elemento: ", i+1); aponta para o valor final, o que denominado
scanf("%d", &v[i]); /* armazena o valor no vetor na posio i */
} indireo mltipla.
for (i =0; i<n; i++)
printf("%d ", v[i]); A indireo mltipla pode ser levada a qualquer
free(n); /* libera a memria alocada para o vetor */ dimenso desejada.
return 0;
}

19 20

Alocao dinmica de matrizes Alocao dinmica de matrizes

#include <stdio.h> v = (float **) calloc(m, sizeof(float *)); /* aloca as linhas da matriz */
#include <stdlib.h> if (v == NULL) {
printf ("** Erro: Memoria Insuficiente **");
return NULL;
float **Alocar_matriz_real(int m, int n) { }
float **v; /* ponteiro para a matriz */ for ( i = 0; i < m; i++ ) { /* aloca as colunas da matriz */
int i; /* varivel auxiliar */ v[i] = (float*) calloc(n, sizeof(float));
if (v[i] == NULL) {
printf ("** Erro: Memoria Insuficiente **");
if (m < 1 || n < 1) { /* verifica parmetros */ return NULL;
printf ("** Erro: Parametro invalido **\n"); }
return NULL; }
return v; /* retorna o ponteiro para a matriz */
} }

21 22

Alocao dinmica de matrizes Alocao dinmica de matrizes

float ** liberar_matriz_real (int m, int n, float **v) { void main () {
int i; /* varivel auxiliar */ float **mat; /* matriz a ser alocada */
int l, c; /* numero de linhas e colunas */
if (v == NULL) return NULL; ...
/* outros comandos, inclusive inicializao de l e c */
if (m < 1 || n < 1) { /* verifica parmetros recebidos */
printf ("** Erro: Parametro invalido **\n");
mat = Alocar_matriz_real (l, c);
return v; /* outros comandos utilizando mat[][] normalmente */
} if (Liberar_matriz_real (l, c, mat) != NULL) {
for (i = 0; i < m; i++) free (v[i]); /* libera as linhas da matriz */ printf("Erro ao desalocar a matriz!\n");
exit(1);
free (v); /* libera a matriz */ }
return NULL; /* retorna um ponteiro nulo */ ...
} }

23 24

4
 Exerccios
1) Escreva um programa em linguagem C que
solicita ao usurio a quantidade de alunos de
uma turma e aloca um vetor de notas
(nmeros reais). Depois de ler as notas,
imprime a mdia aritmtica.
Obs: no deve ocorrer desperdcio de
memria; e aps ser utilizada a memria
deve ser devolvida.
Exerccios
2) Desenvolva um programa que calcule a soma
de duas matrizes MxN de nmeros reais
(double). A implementao deste programa
deve considerar as dimenses fornecida pelo
usurio (Dica: represente a matriz atravs de
variveis do tipo double **, usando alocao
dinmica de memria)..