Calloc em c

“Diz -se que a utilização e a atribuição de memória ou espaço em um sistema é a coisa mais importante em qualquer script de programação quando você tem muitos dados na forma de variáveis ​​e matrizes. A linguagem C é muito dinâmica quando se trata de alocar memória, pois contém muitas funções específicas da memória. Uma dessas funções é Calloc (). A alocação contígua é outro nome para o "Calloc". Este método de linguagem C aloca memória dinâmica para um determinado tipo. Esta técnica é usada para alocar dinamicamente o número desejado de blocos de memória de um tipo específico.”

Essa abordagem é bastante semelhante ao método malloc da linguagem C, mas há duas diferenças dadas abaixo:

1. Cada bloco nesta função recebe uma inicialização zero e um tipo específico é alocado.
2. Comparado ao MALLOC, ele contém dois argumentos ou parâmetros.

Sintaxe

(tipo de elenco*) Calloc (n, tamanho);

Podemos lançar a memória retornada para qualquer tipo de memória apropriado, porque esta função retorna um ponteiro vazio para o endereço necessário na memória. Por exemplo:

ptr = (int*) calloc (20, sizeof (int));

O código acima é usado para alocar 20 blocos contíguos de memória do tamanho inteiro, cada um contendo 20 elementos.

Exemplo 1

Vamos começar escrevendo um código simples. Neste exemplo, usamos o Visual Studio para criar um projeto C vazio e adicionar um arquivo chamado como forkexample.C no diretório/pasta de arquivos de origem. Examine o código na seção abaixo. As duas primeiras linhas na amostra abaixo são usadas para incluir os arquivos de cabeçalho necessários. Então, a função principal começa. Tome nota do uso de (Float*) para mudar o ponteiro vazio em um ponteiro de flutuação. Este comando dentro da função principal aloca espaço de memória contíguo usando a função Calloc para 25 elementos, cada um do tamanho da flutuação.

Como essa memória é dinâmica, ela será alocada quando o arquivo for executado; No entanto, ele será lançado após a conclusão do ciclo de execução do programa. Ele demonstra apenas como uma alocação de memória pode ser realizada usando a função Calloc; Nenhuma saída específica será apresentada ao usuário na tela, pois nenhuma função printf é utilizada. A declaração condicional deve ser usada para determinar se a memória foi alocada ou não.

#incluir
#incluir
int main ()
flutuar* a = (float*) calloc (25, sizeof (float));
retornar 0;

Exemplo 2

As duas primeiras linhas do código de amostra abaixo incluem os arquivos de cabeçalho necessários. O método principal começa então. Na primeira linha da função principal, lançamos o tipo de dados de ponto para um número inteiro e usamos a função Calloc para alocar 25 blocos de memória com um tamanho inteiro. Declaramos uma variável do tipo inteiro na linha a seguir, que mais tarde empregaremos para exibir a saída na tela. Na frase seguinte, usamos a condição IF para determinar se o ponto de calloc retorna um valor nulo ou não. Somente nessas circunstâncias, como quando uma alocação falha ou espaço de memória não é alocada, o valor nulo retorna.

Nessa situação, usamos a função PrintF para exibir a mensagem "Memória não permitida" ou "Calloc falhou em alocar a memória.”Mostramos a mensagem de sucesso na tela de outra maneira. A entrada do usuário é coletada na próxima linha e armazenada na variável declarada anterior.

#incluir
#incluir
int main ()
int* ponteiro = (int*) calloc (25, sizeof (int));
int a;
if (ponteiro == null)
printf ("Memória não alocada.\ n ");
outro
printf ("Memória alocada com sucesso usando a função Calloc.\ n ");
scanf ("%d", & a);
retornar 0;

Aqui está a saída da tela mostrando que o método Calloc aloca com sucesso a memória.

Vamos tentar falhar neste procedimento, fazendo uma pequena alteração no código mostrado acima. Para fazer isso, devemos aumentar o tamanho do número de itens que exigem esse tamanho. Esse código modificado apenas modifica a primeira linha do método principal, define o número de elementos e passa o valor 2500000000000000000 para a função Calloc.

#incluir
#incluir
int main ()
int* ponteiro = (int*) calloc (250000000000000000000, sizeof (int));
int a;
if (ponteiro == null)
printf ("Memória não alocada.\ n ");
outro
printf ("Memória alocada com sucesso usando a função Calloc.\ n ");
scanf ("%d", & a);
retornar 0;

O programa é executado com sucesso quando executamos o código, mas o Calloc retorna nulo, indicando que o programa não pode alocar a quantidade solicitada de memória.

Exemplo 3

Neste exemplo, estamos solicitando a entrada do usuário sobre o número de elementos necessários para armazenar os blocos de memória. Os arquivos de cabeçalho necessários estão incluídos nas duas primeiras linhas do arquivo. A função principal principal () então começa. Declaramos 4 variáveis ​​do tipo inteiro na função principal, a primeira das quais é uma variável de tipo de ponteiro que é usada principalmente para armazenar a saída da função Calloc. O restante das variáveis ​​são números inteiros simples. O cliente é solicitado a inserir o número de elementos para os quais a alocação de memória é necessária para a seguinte linha.

Para alocação de tamanho de bloco de memória, estamos utilizando a função Sizeof para obter o tamanho do tipo de dados inteiro. A entrada do usuário do usuário é obtida usando a função SCANF. A saída da função Calloc é então verificada para determinar se foi bem -sucedido ou não. Se o processo de alocação de memória for bem -sucedido, não são retornados valores nulos. Se o resultado for encontrado, exibimos uma mensagem de sucesso e depois utilizamos um loop for para solicitar ao usuário suas marcas em todos os assuntos.

#incluir
#incluir
int main ()
Int* ponteiro;
INT nelementos, marcas;
int sum = 0;
printf ("Digite o número de elementos (dados dos sujeitos) necessários:");
scanf ("%d", & nelements);
ponteiro = (int*) calloc (nelementos, sizeof (int));
if (ponteiro == null)
printf ("Memória não alocada.\ n ");
saída (0);
outro
printf ("Memória alocada com sucesso usando a função Calloc.\ n ");
para (int i = 0; i < nElements; i++);
int marks = 0;

Exibiremos a pontuação geral do usuário usando a variável de alocação de memória. Portanto, solicitamos ao usuário que insira o número de elementos ou assuntos para os quais a alocação de memória é necessária em primeiro lugar apenas para esse fim. Depois que a memória foi alocada corretamente, utilizamos uma variável de ponteiro para armazenar as marcas do tópico. As marcas para cada sujeito são exibidas posteriormente no loop for, e a soma das marcas é exibida no final, utilizando o loop para executar a função da soma.

printf ("Digite as marcas do sujeito (%d):", i);
scanf ("%d", & Marks);
ponteiro [i] = marcas;
printf ("as disciplinas do aluno Marks \ n");
para (int i = 0; i < nElements; ++i)
printf ("sujeito %d - [ %d] \ n", (i+1), poinyer [i]);
soma = soma+ponteiro [i];
printf ("Total Marks: %d", soma);

scanf ("%d%", & nelements);
retornar 0;

Aqui está a saída do código do snippet acima:

Conclusão

Este artigo demonstra a função de memória Calloc em C usando três exemplos diferentes, porém simples. Os exemplos elaboram que, se não houver espaço de memória suficiente disponível, essa alocação de memória falha e retorna um ponteiro nulo, indicando que foi uma falha através da função Calloc de C.