LPG - I: Alocação Dinâmica de Memória - Ponteiros UDESC - SBS Departamento de Sistemas de Informação LPG - I: Alocação Dinâmica de Memória - Ponteiros Prof. Flavio Marcello Strelow flavio@sbs.udesc.br

Memória Disponível no Computador PROGRAMA ÁREA LIVRE Memória livre, gerenciada pelo sistema operacional Código executável: - instruções (compilador) - armazenamento do dados (estrutura dos dados)

Alocação de Memória - Estática Quantidade total de memória utilizada pelos dados é previamente conhecida e definida de modo imutável, no próprio código-fonte do programa. Durante toda a execução, a quantidade de memória utilizada pelo programa não varia. Lista de variáveis declaradas.

Alocação de Memória - Estática Implementação simples: vetores (array) Vantagem: acesso indexado (vi)- todos os elementos da estrutura são igualmente acessíveis Desvantagens: tamanho fixo (#define TAM 1000) tempo de compilação alocados em memória de forma estática

Alocação de Memória - Estática Ao se determinar o máximo de elementos que o vetor irá conter, pode-se ocorrer um dos seguintes casos: Subdimensionamento: haverá mais elementos a serem armazenados do que o vetor é capaz de conter; Superdimensionamento: na maior parte do tempo, somente uma pequena porção do vetor será realmente utilizada.

Alocação de Memória - Dinâmica Quanto o programa é capaz de criar novas variáveis enquanto está sendo executado. Alocação de memória para componentes individuais no instante em que eles começam a existir durante a execução do programa.

Alocação Estática x Alocação Dinâmica

Alocação Dinâmica Implementação eficiente: ponteiros ou apontadores Vantagens: tamanho variável tempo de execução alocados em memória de forma dinâmica Desvantagem, ou restrição: capacidade da memória, acesso seqüencial

Alocação de Memória - Ponteiros No padrão C ANSI que define as funções para a alocação dinâmica (alocar e liberar blocos de memória em tempo de execução) estão disponíveis na biblioteca stdlib.h. malloc: alocar memória. free: liberar áreas da memória ocupadas. Precisaremos tambem do: sizeof: retorna o tamanho de uma variável.

Operador sizeof() sizeof sizeof(<expressão> | <tipo>) Retorna o número de bytes necessários para armazenar um objeto na memória, ou seja, saber o tamanho de tipos . O objeto pode ser um vetor, estrutura(struct) ou uma expressão como 5+9 ou 2.5*3.

Alocação de Memória - malloc void* malloc(tamanho_a_alocar); Recebe o número de bytes a alocar. Retorna um apontador void para a base da região contígua alocada na memória ou NULL se não for possível alocá-la. É responsabilidade do programador liberar a memória alocada dinamicamente com free. Produz erros estranhos quando usada para liberar um espaço que já foi liberado.

Alocação de Memória - Exemplos Alocação de memória para um inteiro: int *p = malloc( 3 * sizeof(int)); Alocação de memória para um array de n reais: float *p = malloc(n * sizeof(float));

Representação Interna da Variável do Tipo Ponteiro: void main() { int *p; p = (int *) malloc(sizeof(int)); *p = 10; ... free(p); } aloca a variável estaticamente I aloca a variável dinamicamente II III IV Lixo memória usada pelo programa p: memória livre no sistema memória usada pelo programa endereço 1FFA Lixo 10 p: 1FFA Lixo memória livre no sistema

Entendendo o código: I - int *p; A variável p é um ponteiro para um número inteiro, ou seja, “aponta” para um endereço de memória que será “alocado” para armazenar um número inteiro (2 bytes) II - p = (int *) malloc(sizeof(int)); Solicita ao sistema operacional 2 bytes da memória livre e o “endereço do espaço alocado” é colocado na variável ponteiro p III - *p = 10; No endereço apontado por p armazena o número inteiro 10 IV - free(p); Libera o espaço de memória ocupado cujo endereço está em p (devolve o recurso ao sistema operacional)

Exemplo Faça um programa para ler 10 números reais e armazene em um vetor alocado dinamicamente. Depois, imprima os elementos lidos.

Exemplo #include <stdio.h> #include <conio.h> #include <stdlib.h> #define TAM 10 int main() { int *pti, i; pti= (int *) malloc(sizeof(int) * TAM); if (pti == NULL) { /* verifica alocação, (poderia ser  if(!pti)) */ printf("Erro ao alocar memória!\n"); return 1; /* sai do programa */ } for (i=0; i<TAM; i++) { printf("Digite um numero inteiro: "); scanf("%d", &pti[i]); /* lê e armazena no vetor de endereços */ /* Impressao do ponteiro */ for (i=0; i<TAM; i++) printf("%d", pti[i]); free(pti); // libera memoria. return 0; }

Obrigado Alocação de Ponteiros LPG-I Flavio Marcello

Exercícios Faça um programa que aloque uma string de 30 caracteres, armazene uma palavra digitada pelo usuário nesta string, imprima na tela e, depois de imprimido, desaloque esta string. Faça um programa que leia 5 strings e armazene em uma matriz de strings. Cada string deve ter seu espaço alocado dinamicamente (considere strings de no máximo 20 caracteres na leitura).

3) Faça um programa que aloque uma string de 30 caracteres, armazene uma palavra digitada pelo usuário nesta string, imprima na tela e, depois de imprimido, desaloque esta string. #include <stdio.h> #include <stdlib.h> main() { char *string; /* alocar a string de 30 caracteres */ string= (char *) malloc(sizeof(char) * 30); if (!string) /* se alocação falhou (se string for igual a NULL) */ printf("Erro ao alocar memória!\n"); return 1; /* sai do programa */ } printf("Digite uma palavra: "); fgets(string, 30, stdin); printf("A palavra digitada é %s\n", string); free(string); /* desaloca a string */ return 0;

/*4) Faça um programa que leia 5 strings e armazene em uma matriz de strings. Cada string deve ter seu espaço alocado dinamicamente (considere strings de no máximo 20 caracteres). */ #include <stdio.h> #include <stdlib.h> main() { char *mat[5]; int i; for (i=0; i<5; i++) { /* aloca espaço para as strings */ mat[i]= (char *) malloc(sizeof(char) * 20); if (!mat[i]) { printf("Falha na alocação de memória!\n"); return 1; } printf("Digite uma palavra: "); fgets(mat[i], 20, stdin); /* imprime as strings */ for (i=0; i<5; i++) { puts(mat[i]); free(mat[i]); /* desaloca a string */ return 0; /* OBS: Quando um dado é alocado dinamicamente, é importante desalocá-lo antes de encerrar o programa. Se isso não for feito, a variável continuará ocupando espaço desnecessariamente após o término da execução do programa. Também é importante testar se ocorreu algum erro na alocação, para tratá-lo, se houver. */