O documento descreve conceitos de alocação dinâmica de memória em C, incluindo o uso das funções malloc(), calloc(), realloc() e free(). Explica como alocar e libertar memória para estruturas e vetores, e como redimensionar blocos de memória alocados.

1. Escola Secundária c/ 3º CEB da Batalha Alocação dinâmica de memória

2. Composição de Estruturas struct rectangulo { struct ponto inicio; struct ponto fim; }; struct rectangulo r = { { 10, 20 }, { 30 , 40 } }; Acesso aos dados: r.inicio.x += 10; r.inicio.y -= 10; r inicio x: y: 10 20 fim x: y: 30 40

3. Ponteiros para Estruturas Estruturas grandes são passadas como parâmetro De forma mais eficiente através de ponteiros struct ponto *pp; struct ponto p1 = { 10, 20 }; pp = &p1; printf(“Ponto P1: (%d %d)\n”, (*pp).x, (*pp).y}; Aceder com o operador “->”: printf(“Ponto P1: (%d %d)\n”, pp->x, pp->y}; (*pp).x == pp->x pp 1002 p1 x: y: 1002 10 20

4. Alocação Dinâmica de Memória incluir a biblioteca standard do C: stdlib.h (malloc() e free()) possibilidade de libertar memória à medida que deixa de ser precisa as funções calloc e malloc permitem alocar blocos de memória em tempo de execução void * malloc( ); /* retorna um ponteiro void para n bytes de memória não iniciados. Se não há memória disponível malloc retorna NULL */ número de bytes alocados size_t n

5. Alocação Dinâmica de Memória A função malloc () ( memory allocation ) reserva uma porção de memória, retornando um apontador genérico (tipo void *) para o ínicio da porção reservada, ou o valor NULL no caso da reserva ser impossível A sua utilização é representada no exemplo seguinte: int *pi; pi= ( int *) malloc (sizeof( int )); /* aloca espaço para um inteiro */

6. malloc () – exemplo float *v; int n; printf("Quantos valores? "); scanf("%d", n); v = (float *) malloc(n * sizeof(float) ); Neste exemplo, é reservada uma porção de memória capaz de guardar n números reais ( float ), ficando o apontador v a apontar para o endereço inicial dessa porção de memória. O cast da função malloc() - (float *) - assegura que o apontador retornado é para o tipo especificado na declaração do apontador. Certos compiladores requerem obrigatoriamente o cast . Pág.424

7. malloc () Conselho: não altere o valor do apontador que recebeu o retorno da função malloc(). Desta forma poderá sempre saber onde começa o bloco de memória dinâmica reservado. Utilize apontadores auxiliares para realizar operações (leitura, escrita) dentro do bloco de memória. float *v,*paux; int n; printf("Quantos valores? "); scanf("%d", n); v = (float *) malloc(n * sizeof(float) ); paux=v;

8. Libertar memória dinâmica A memória é libertada utilizando a função free() int *pi; pi= ( int *) malloc (sizeof( int )); Para libertar a memória: free(pi);

9. Exercícios 1-Diga qual o output do seguinte programa: int *p; p = (int *) malloc (sizeof(int)); ou (int *) malloc (1); scanf (&quot;%d&quot;, p); *p = *p + 142; printf (&quot;%d&quot;, *p); free (p); 2-Faça a alocação de um vector, durante a execução de um programa, com n elementos inteiros (n é dado pelo utilizador) int *v; int n, i; scanf (&quot;%d&quot;, &n); v = (int *) malloc (n * sizeof(int)); for (i = 0; i < n; ++i) v[i] = i; . . . free (v);

10. Ajuste de memória dinâmica É possível alterar o tamanho do bloco de memória reservado, utilizando a função realloc() . Esta função salvaguarda os valores anteriormente digitados em memória, até ao limite do novo tamanho (especialmente importante quando se reduz o tamanho do bloco de memória). O seguinte exemplo ilustra a forma de utilização desta função.

11. Ajuste de memória dinâmica int *a; a = (int *) malloc( 10 * sizeof(int) ); (...) a = (int *) realloc( a, 23 * sizeof(int) ); (...) free(a); A chamada da função realloc() recebe como argumentos um apontador para o bloco de memória previamente reservado com uma função malloc() de forma a saber qual a porção de memória a ser redimensionada, e o novo tamanho absoluto para o bloco de memória.

12. Alocação Dinâmica de Memória 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 não houver memória disponível. Os elementos são iniciados em zero */ o ponteiro retornado por malloc e calloc deve ser convertido para o tipo de ponteiro que invoca a função:

13. Alocação Dinâmica de Memória int *ai = ( int *) calloc (n, sizeof( int )); /* aloca espaço para um array de n inteiros */ toda memória não mais utilizada deve ser liberada através da função free() : free(ai); /* libera todo o array */ free(pi); /* libera o inteiro alocado */

14. Exercícios 1- Pretende-se que faça a alocação de espaço em memória para 10 inteiros. Deverá imprimir os seus respectivos endereço de memórias e o seu conteúdo. 2- Leia uma sequência de 10 números to teclado usando apontadores em lugar de índices. Usando a mesma técnica (apontadores) determine o maior e o menor valor. Reserve memória dinâmica em vez de declarar o vector de uma forma estática. 3- Ler uma sequência de números do teclado (sequência terminada em zero ).Escreva no ecrã os números que estão acima da média. Utilize um vector dinâmico para armazenar os números.

15. Resolução Nº 1 1- Pretende-se que faça a alocação de espaço em memória para 10 inteiros. Deverá imprimir os seus respectivos endereço de memórias e o seu conteúdo. int *dados,i;int *p; void main() { clrscr(); dados=(int *)malloc(5*sizeof(int)); if (dados==NULL) { printf (&quot;A alocação não correu bem!!&quot;); exit(1); } p=dados; for (i=0;i<5;i++) { printf(&quot;Digite os numeros&quot;); scanf(&quot;%d&quot;,dados+i);//guarda valores am mem¢ria } for (i=0;i<5;i++) { printf(&quot;Tem o valor %d e est no endere‡o %d\n&quot;, *(dados+i),p); //endere‡o de mem¢ria p++; } getch(); }

16. Resolução Nº 2 Leia uma sequência de 10 números to teclado usando apontadores em lugar de índices. Usando a mesma técnica (apontadores) determine o maior e o menor valor. Reserve memória dinâmica em vez de declarar o vector de uma forma estática. #include <stdio.h> #include <stdlib.h> void main() { int *v, *min, *max; int i, soma = 0; float media; /* v passa a apontar para um bloco de memória com capacidade para 10 inteiros */ v = (int *) malloc(10 * sizeof(int)); for(i = 0; i < 10; i++) { printf(&quot;Insira um número: &quot;); scanf(&quot;%d&quot;, v+i); } /* min e max passam a apontar para o primeiro valor do vector */ min = v; max = v; for(i = 0; i < 10; i++) { if ( *(v+i) > *max ) max = v+i; else if ( *(v+i) < *min ) min = v+i; } printf(&quot;O menor número inserido: %d\n&quot;, *min); printf(&quot;O maior número inserido: %d\n&quot;, *max); free(v); }

17. Resolução Nº 3 Ler uma sequência de números do teclado (sequência terminada em zero ).Escreva no ecrã os números que estão acima da média. Utilize um vector dinâmico para armazenar os números. #include <stdio.h> #include <stdlib.h> void main() { int *v; int soma, i, num, c; float media; /* Esta operação é necessária para utilizar posteriormente a função realloc() */ v = (int *) malloc( sizeof(int) ); /* São inicializadas as variáveis soma e contador de números inseridos */ soma = 0; i = 0; /* O primeiro número é inserido antes do ciclo while para verificar se é zero (para a acabar) */ printf(&quot;Insira um número (zero para acabar): &quot;); scanf(&quot;%d&quot;, &num); while( num ) /* O ciclo é executado enquanto num não é zero */ { i++; v = (int *) realloc(v, i*sizeof(int)); *(v+i-1) = num; /* O vector começa na posição zero pelo que i anda avançado um valor */ soma += num; /* É efectuado o somatório dos números inseridos */ /* É inserido um novo número para verificar no início do próximo ciclo */ printf(&quot;Insira um número (zero para acabar): &quot;); scanf(&quot;%d&quot;, &num); } /* O cast (float) força as operações a serem realizadas no domínio dos float */ /* que de outra forma seria nos int (soma e i são ambos inteiros) */ media = (float) soma / i; for(c = 0; c < i; c++) if ( *(v+c) > media ) printf(&quot;O valor %d está acima da média.\n&quot;, *(v+i)); }