Alocação de memória dinâmica em C

Na DMA, a decisão sobre memórias que são alocadas não podem tomar durante o tempo de compilação. Esta decisão ou memória é alocada durante o tempo de execução.

Sempre que criamos qualquer variável através do DMA, esse tipo de variável não tem nenhum nome; Acessamos essas variáveis ​​através do endereço ou ponteiro.

Na SMA, o programador sabe desde o início que quantas variáveis ​​ou quantas memórias são necessárias para o seu programa.

Mas no DMA, o programador não sabe do estado anterior que quantas variáveis ​​ou memória são necessárias, depende do requisito do usuário.

Tipos de DMA:

1. Malloc ()
2. calloc ()
3. realloc ()
4. Livre ()

Malloc ()

Função Malloc () é uma declaração de ação quando o compilador leu esta linha. O compilador não entende quantas memórias são alocadas, pois é uma declaração de ação. No bloco de memória de tempo de execução é criado.

Sempre que chamamos de Malloc (), passamos um número como um argumento, que pode entender o número de bytes do bloco de memória, deve ser criado pelo Malloc (). Em Malloc (), ele não pode declarar nenhum tipo de dados. Malloc () sempre retorna o endereço, cujo bloco de memória é criado.

O tipo de retorno malloc () é um ponteiro vazio, porque não sabe quais tipos de endereço ele retorna. Para isso, temos que digitar casta.

P = (flutuação*) malloc (4);

Aqui digitamos casta, porque Malloc () é um ponteiro vazio.

Exemplo 1:

#incluir
#incluir
#Define null 0
int main ()

int *a, *t;
Int tamanho;
printf ("Qual é o tamanho da tabela ? ");
scanf ("%d", & size);
printf ("\ n");
if ((t = (int *) malloc (tamanho * sizeof (int))) == null)

printf ("sem espaço disponível \ n");
saída (1);

printf ("\ n endereço do primeiro byte é %u \ n", t);
/* Valores da tabela de leitura*/
printf ("\ n Tabela de entrada valores \ n");
para (a = t; a < t + size ; a++ )
scanf ("%d", a);
/* Valores da tabela de impressão em ordem inversa*/
for (a = t + tamanho - 1; a> = t; a -)
printf (" %d é armazenado no endereço %u \ n", *a, a);
grátis (t);
retornar 0;

Saída:

Calloc ():

Com a ajuda do Calloc (), podemos criar mais de um bloco ou matriz no Calloc (passamos dois argumentos; 1º é quantos blocos queremos criar e o segundo é o tamanho do bloco). Calloc () também retorna o endereço em cada bloco por padrão 0 existe.

Exemplo 2:

#incluir
#incluir
int main ()

int *n, *freq, i, tamanho;
printf ("Qual é o tamanho da lista ? ");
scanf ("%d", & size);
n = (int *) malloc (tamanho * sizeof (int));
printf ("Digite os números:");
para (i = 0; i < size ; i++ )

printf ("\ n digite o num [%d]:", i);
scanf ("%d", & n [i]);
if (n [i] < 0 || n [ i ] > 4)

printf ("\ n número deve estar dentro do intervalo (0-4)");
eu-- ;
continuar ;


Freq = (int *) Calloc (5, sizeof (int));
para (i = 0; i < size ; i++ )
freq [n [i]] ++;
printf ("\ n As frequências dos números são:");
para (i = 0; i < 5 ; i++ )
printf ("\ n freq [ %d] = %d", i, freq [i]);
printf ("\ n");
grátis (Freq);
retornar 0;

Saída:

realloc ()

Sempre que criamos um bloco com a ajuda de Malloc () ou Calloc () e queremos alterar ou redimensionar o bloco, usamos realloc ().

Void *realloc (bloqueio void *, tamanho int)

Em realloc (), temos que passar o endereço como um argumento de qual bloco queremos redimensionar.

realloc (PTR, 8);

e o tamanho do bloco que queremos redimensionar. Esse tamanho que temos que passar um argumento no realloc ().

duplo *q;
q = realloc (ptr, 8);

Somente os blocos criados por MALLOC () ou Calloc () podem ser redimensionados pelo RealLoc ().

Exemplo 3:

#incluir
#incluir
#incluir
#Define null 0
int main ()

char *buffer;
/ * Alocando a memória */
if ((buffer = (char *) Malloc (10)) == NULL)

printf ("Malloc falhou. \ n ");
saída (1);

printf ("buffer de tamanho %d criado \ n", sizeof (buffer));
strcpy (buffer, "hyderabad");
printf ("\ n buffer contém: %s \ n", buffer);
/* Realocação */
if ((buffer = (char *) realloc (buffer, 15)) == null)
printf ("Realoclocation falhou. \ n ");
saída (1);

printf ("\ n tamanho do buffer modificado. \ n ");
printf ("\ n buffer ainda contém: %s \ n", buffer);
strcpy (buffer, "Secunderabad");
printf ("\ n buffer agora contém: %s \ n", buffer);
/ * Liberando memória */
grátis (buffer);
retornar 0;

Saída:

livre ()

Com a ajuda de Free (), lançamos o bloco de memória criado por Malloc () ou Calloc () ou RealLoc ().

Variáveis ​​estáticas só existem no escopo do bloco ou uma função. Se não podemos executar o livre (), sempre que a variável estática P é destruída, a variável que é criada dinamicamente, que não é destruída, mas permaneceu para sempre em RAM ou na memória. Isso é chamado de vazamento de memória. Para este grátis () é necessário para destruir o bloco de memória que é criado dinamicamente.

Livre () apenas destroe aqueles que são criados dinamicamente.

Conclusão:

DMA é um conceito poderoso na linguagem C porque remove a desvantagem da SMA. Na SMA, temos que tomar uma decisão antes de executar o programa de que quantos blocos de memória são criados. Como resultado, a memória é desperdiçada ou a memória não é suficiente. DMA Resolva o problema tomando decisão sobre o tempo de execução de quantos blocos são necessários para alocar a memória. Aloca memória para o requisito do programa.