Calloc in c

“Si dice che l'utilizzo e l'assegnazione della memoria o dello spazio in un sistema siano la cosa più importante in qualsiasi script di programmazione quando si dispone di molti dati sotto forma di variabili e array. Il linguaggio C è molto dinamico quando si tratta di allocare la memoria in quanto contiene molte funzioni specifiche della memoria in essa. Una di queste funzioni è caloc (). L'allocazione contigua è un altro nome per il "caloc". Questo metodo del linguaggio C assegna la memoria dinamica per un determinato tipo. Questa tecnica viene utilizzata per allocare dinamicamente il numero desiderato di blocchi di memoria di un particolare tipo."

Questo approccio è abbastanza simile al metodo Malloc della lingua C, ma ci sono due differenze riportate di seguito:

1. Ogni blocco in questa funzione viene data un'inizializzazione zero e viene assegnato un tipo specifico.
2. Rispetto a Malloc, contiene due argomenti o parametri.

Sintassi

(tipo cast*) caloc (n, dimensioni);

Possiamo lanciare la memoria restituita a qualsiasi tipo di memoria appropriato perché questa funzione restituisce un puntatore vuoto all'indirizzo necessario in memoria. Per esempio:

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

Il codice sopra viene utilizzato per allocare 20 blocchi di memoria contigui di dimensioni interi, ciascuno contenente 20 elementi.

Esempio 1

Cominciamo con la scrittura di un codice semplice. In questo esempio, utilizziamo Visual Studio per creare un progetto C vuoto e aggiungere un file chiamato forKexample.C Nella directory/cartella dei file di origine. Esamina il codice nella sezione seguente. Le prime due righe nel campione seguente vengono utilizzate per includere i file di intestazione necessari. Quindi, inizia la funzione principale. Prendi nota dell'uso di (float*) per cambiare il puntatore vuoto in un puntatore galleggiante. Questo comando all'interno della funzione principale alloca lo spazio di memoria contiguo usando la funzione Calloc per 25 elementi, ciascuno della dimensione del galleggiante.

Poiché questa memoria è dinamica, verrà assegnato quando viene eseguito il file; Tuttavia, verrà rilasciato dopo il completamento del ciclo di esecuzione del programma. Dimostra solo come un'allocazione di memoria può essere eseguita utilizzando la funzione Calloc; Non verrà presentato alcun output specifico all'utente sullo schermo poiché non viene utilizzata alcuna funzione printf. L'istruzione condizionale deve essere utilizzata per determinare se la memoria è stata assegnata o meno.

#includere
#includere
int main ()
float* a = (float*) caloc (25, sizeof (float));
restituzione 0;

Esempio 2

Le prime due righe del codice di esempio di seguito includono i file di intestazione necessari. Il metodo principale inizia quindi. Nella prima riga della funzione principale, lanciamo il tipo di dati punti su un numero intero e utilizziamo la funzione Calloc per allocare 25 blocchi di memoria con una dimensione intera. Abbiamo dichiarato una variabile di tipo intero nella riga seguente, che in seguito impiegheremo per visualizzare l'output sullo schermo. Nella frase seguente, utilizziamo la condizione IF per determinare se il punto Calloc restituisce o meno un valore nullo. Solo in tali circostanze, ad esempio quando un'allocazione fallisce o lo spazio di memoria non viene assegnato, il valore nullo ritorna.

In quella situazione, utilizziamo la funzione printf per visualizzare il messaggio "memoria non consentita" o "Calloc non è riuscito ad allocare la memoria."Mostriamo il messaggio di successo sullo schermo in un altro modo. L'input dell'utente viene raccolto sulla riga successiva e memorizzata nella variabile dichiarata precedente.

#includere
#includere
int main ()
int* puntatore = (int*) caloc (25, sizeof (int));
int a;
if (puntatore == null)
printf ("memoria non assegnata.\N");
altro
printf ("memoria allocata correttamente utilizzando la funzione caloc.\N");
scanf ("%d", & a);
restituzione 0;

Ecco l'output dello schermo che mostra che il metodo Calloc alloca correttamente la memoria.

Proviamo a fallire questa procedura apportando una piccola modifica al codice sopra. Per fare ciò, dobbiamo aumentare la dimensione del numero di articoli che richiedono questa dimensione. Questo codice modificato modifica solo la prima riga del metodo principale, imposta il numero di elementi e passa il valore 2500000000000000000 alla funzione Calloc.

#includere
#includere
int main ()
int* puntatore = (int*) caloc (250000000000000000000, sizeof (int));
int a;
if (puntatore == null)
printf ("memoria non assegnata.\N");
altro
printf ("memoria allocata correttamente utilizzando la funzione caloc.\N");
scanf ("%d", & a);
restituzione 0;

Il programma è eseguito correttamente quando eseguiamo il codice, ma il Calloc restituisce null, indicando che il programma non può allocare la quantità richiesta di memoria.

Esempio 3

In questo esempio, stiamo richiedendo l'input dell'utente in merito al numero di elementi necessari per archiviare i blocchi di memoria. I file di intestazione necessari sono inclusi nelle prime due righe del file. La funzione principale principale () inizia quindi. Abbiamo dichiarato 4 variabili di tipo intero nella funzione principale, la prima della quale è una variabile di tipo puntatore che viene utilizzata principalmente per archiviare l'output della funzione caloc. Il resto delle variabili sono interi semplici. Al cliente viene richiesto di inserire il numero di elementi per i quali è necessaria l'allocazione della memoria per la riga seguente.

Per l'allocazione delle dimensioni del blocco di memoria, stiamo utilizzando la funzione di dimensione per ottenere la dimensione del tipo di dati interi. L'input di tipo intero dell'utente è ottenuto utilizzando la funzione scanf. L'output della funzione Calloc viene quindi verificato per determinare se ha avuto successo o meno. Se il processo di allocazione della memoria ha esito positivo, non vengono restituiti i valori null. Se viene trovato il risultato, visualizziamo un messaggio di successo e quindi utilizziamo un ciclo per richiedere l'utente per i loro marchi su tutti i soggetti.

#includere
#includere
int main ()
int* puntatore;
int Nellements, Marks;
int sum = 0;
printf ("Immettere il numero di elementi (dati dei soggetti) richiesti:");
scanf ("%d", & purements);
puntatore = (int*) caloc (Nelments, sizeof (int));
if (puntatore == null)
printf ("memoria non assegnata.\N");
uscita (0);
altro
printf ("memoria allocata correttamente utilizzando la funzione caloc.\N");
per (int i = 0; i < nElements; i++);
int marks = 0;

Visualmente visualizzeremo il punteggio complessivo dell'utente utilizzando la variabile di allocazione della memoria. Pertanto, chiediamo all'utente di inserire il numero di elementi o soggetti per i quali l'allocazione della memoria è necessaria in primo luogo solo a tale scopo. Dopo che la memoria è stata assegnata correttamente, utilizziamo una variabile puntatore per archiviare i segni di argomento. I segni per ogni soggetto vengono visualizzati più avanti nel ciclo per loop e la somma dei segni viene visualizzata alla fine utilizzando il ciclo per eseguire la funzione di somma.

printf ("Immettere segni del soggetto (%d):", i);
scanf ("%d", & marks);
puntatore [i] = segni;
printf ("The Student Soggets segna \ n");
per (int i = 0; i < nElements; ++i)
printf ("soggetto %d - [ %d] \ n", (i+1), poinyer [i]);
Sum = Sum+puntatore [i];
printf ("segni totali: %d", somma);

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

Ecco l'output del codice di snippet sopra:

Conclusione

Questo articolo dimostra la funzione di memoria Calloc in C utilizzando tre esempi diversi ma semplici. Gli esempi elaborano che se non è disponibile uno spazio di memoria insufficiente, questa allocazione della memoria fallisce e restituisce un puntatore nullo, indicando che si trattava di un errore tramite la funzione Calloc di C.