Ez a témakör azt tárgyalja, hogyan lehet dinamikus memóriafoglalást létrehozni a calloc() függvény használatával a C programozási nyelvben. Mielőtt átmennénk a fogalmakon, beszéljük meg a dinamikus memóriafoglalást C-ben. A dinamikus memória egy struktúraprogramozási eljárás, amely lehetővé teszi a felhasználók számára, hogy a program futási idején lefoglalják a memóriát. A dinamikus memóriafoglalás segítségével egy program végrehajtása során növelhetjük vagy csökkenthetjük a memóriát. Ily módon elkerülhető a számítógép memória pazarlása. A memóriafoglalás két részre oszlik: malloc() és calloc() függvény.
A calloc() függvény egy előre meghatározott könyvtári függvény, amely a összefüggő memóriafoglalás . A calloc() függvény arra szolgál, hogy több blokkot hozzon létre egy ugyanolyan méretű program futási idején a memóriában. A calloc függvény belül van definiálva stdlib.h fejléc fájl. Két paramétere van, nem. blokkok méretét és az egyes blokkok méretét. Ha a dinamikus memóriát a calloc() függvénnyel foglaljuk le, akkor az első blokk alapcímét adja vissza, és minden blokkot 0-val inicializálunk. Ha pedig nem jön létre memória, akkor NULL mutatót ad vissza.
Tegyük fel például, hogy három memóriablokkot szeretnénk létrehozni a calloc() függvény segítségével, két paramétert kell átadnunk, a blokkok számát (3) és az egyes blokkok méretét (int, char, float stb.) a bájt. Ily módon három azonos méretű blokkot hoz létre a számítógép memóriájában.
karaktert karakterláncra
Szintaxis
ptr = (cast_type *) calloc ( number_of_blocks, size_of_block);
A fenti szintaxisban a calloc() függvénynek két paramétere van. Az első paraméter határozza meg a blokkok száma a második paraméter pedig a az egyes blokkok mérete emlékül. A blokkok mérete és a cast_type lehet int, char, float stb.
Visszatérés : Az első blokk alapcímét adja vissza a ptr változónak.
A dinamikus memória ellenőrzésére szolgáló program a calloc() függvény segítségével van lefoglalva
Írjunk egy egyszerű programot annak ellenőrzésére, hogy a dinamikus memória le van-e foglalva C-ben.
program.c
#include #include int main() { int *ptr; /* use calloc() function to define the no. of blocks and size of each blocks. */ ptr = calloc (4, sizeof(int)); // here 4 is the no. of block and int is the size of block if (ptr != NULL) { printf (' Memory is created successfully
'); } else printf (' Memory is not created '); return 0; } Kimenet:
húrt int
Memory is created successfully
Program a calloc() függvény használatának bemutatására
Fontolja meg a dinamikus memóriafoglalás létrehozását a calloc() függvény segítségével, és az adatok tárolását a memóriablokkokban.
Program2.c
hashset vs hashmap
#include #include #include void main() { int n, *ptr, *p, i, sum = 0; /* n = number of elements, *ptr = store base address of the dynamic memory, *p store temporary address of the *ptr */ printf (' Enter the number of elements: '); scanf (' %d', &n); // it takes number of elements // use calloc syntax to create memory block of int data type ptr = (int *) calloc (n, sizeof(int)); p = ptr; // assign the address of ptr if (ptr == NULL) // it checks whether the memory is allocated { printf (' Memory is not allocated. '); exit(0); // exit from the program } printf (' Enter %d numbers
', n); for ( i = 1; i <= n; i++) { scanf ( '%d', ptr); sum="sum" + *ptr; ptr++; } printf (' elements are: '); for (i="1;" i <="n;" %d', *p); p++;
the addition of is: %d ', sum); getch(); pre> <p> <strong>Output:</strong> </p> <pre> Enter the number of elements: 5 Enter 5 numbers 1 2 3 4 5 Elements are: 1 2 3 4 5 The addition of the elements is: 15 </pre> <h3>Program to release dynamic memory allocation using free() function</h3> <p> <strong>free() function:</strong> A free() function is used to release the dynamic memory which is created either <strong>calloc</strong> () or <strong>malloc</strong> () function. These allocated memories cannot be freed to their own, and they will exist till the end of the program. So, it is our responsibility to release that memory that can be reused, and hence we explicitly use the free() function to release the memory.</p> <p> <strong>Syntax</strong> </p> <pre> free (ptr); </pre> <p>Here free() is a function that releases the allocated memory using the pointer ptr variable.</p> <p>Let's consider creating dynamic memory allocation using the calloc() function and then releasing occupied space using the free() function in the C program.</p> <p> <strong>Release.c</strong> </p> <pre> #include #include #include void main() { int n, *ptr, *p, i, sum = 0; printf (' Define the number of elements to be entered: '); scanf (' %d', &n); // use calloc syntax to create memory block of int data type ptr = (int *) calloc (n, sizeof(int)); p = ptr; // store the base address in p if (ptr == NULL) { printf (' Out of memory '); exit(0); } printf (' Enter the elements
', n); for ( i = 1; i <= n; i++) { scanf ( '%d', ptr); sum="sum" + *ptr; ptr++; } printf (' elements are: '); for (i="1;" i <="n;" %d', *p); p++;
the addition of is: %d ', sum); free(ptr); * use free() function to release dynamic memory allocation getch(); pre> <p> <strong>Output:</strong> </p> <pre> Define the number of elements to be entered: 6 Enter the elements 2 4 6 8 10 12 Elements are: 2 4 6 8 10 12 The addition of the elements is: 42 </pre> <hr></=></pre></=> Program a dinamikus memóriafoglalás felszabadítására a free() függvény segítségével
free() függvény: A létrejött dinamikus memória felszabadítására egy free() függvény szolgál calloc () vagy malloc () függvény. Ezeket a lefoglalt memóriákat nem lehet sajátjukra felszabadítani, és a program végéig fennmaradnak. Tehát a mi felelősségünk az újrafelhasználható memória felszabadítása, ezért kifejezetten a free() függvényt használjuk a memória felszabadítására.
Szintaxis
free (ptr);
Itt a free() egy olyan függvény, amely felszabadítja a lefoglalt memóriát a pointer ptr változó használatával.
Fontolja meg a dinamikus memóriafoglalás létrehozását a calloc() függvény segítségével, majd a foglalt hely felszabadítását a C program free() függvényével.
Kiadás.c
#include #include #include void main() { int n, *ptr, *p, i, sum = 0; printf (' Define the number of elements to be entered: '); scanf (' %d', &n); // use calloc syntax to create memory block of int data type ptr = (int *) calloc (n, sizeof(int)); p = ptr; // store the base address in p if (ptr == NULL) { printf (' Out of memory '); exit(0); } printf (' Enter the elements
', n); for ( i = 1; i <= n; i++) { scanf ( \'%d\', ptr); sum="sum" + *ptr; ptr++; } printf (\' elements are: \'); for (i="1;" i <="n;" %d\', *p); p++;
the addition of is: %d \', sum); free(ptr); * use free() function to release dynamic memory allocation getch(); pre> <p> <strong>Output:</strong> </p> <pre> Define the number of elements to be entered: 6 Enter the elements 2 4 6 8 10 12 Elements are: 2 4 6 8 10 12 The addition of the elements is: 42 </pre> <hr></=>