Malloc(), calloc() İşlevlerini Kullanarak C'de Dinamik Bellek Tahsisi

C Dinamik Bellek tahsisini öğrenmeden önce şunları anlayalım:

C'de Bellek Yönetimi nasıl çalışır?

Temel bir veri türü kullanarak bir değişken bildirdiğinizde, C derleyicisi, değişken için otomatik olarak bellek havuzu adı verilen bellek alanını ayırır. yığın.

Örneğin, bir float değişkeni bildirildiğinde genellikle 4 bayt (platforma göre) alır. Bu bilgiyi kullanarak doğrulayabiliriz. sizeof aşağıdaki örnekte gösterildiği gibi operatör

#include <stdio.h>
int main() { float x; printf("The size of float is %d bytes", sizeof(x)); return 0;}

çıkış olacaktır:

 The size of float is 4 bytes

Ayrıca, belirli bir boyuta sahip bir dizi, bitişik bellek bloklarına tahsis edilir; her blok, bir öğenin boyutuna sahiptir:

#include <stdio.h>
int main() { float arr[10];
printf("The size of the float array with 10 element is %d", sizeof(arr)); return 0;}

Sonuç:

 The size of the float array with 10 element is 40

Şu ana kadar öğrenildiği gibi, temel bir veri türü veya dizi bildirildiğinde bellek otomatik olarak yönetilir. Bununla birlikte, C'de, programınızı çalıştırana kadar (çalışma zamanı) dizi boyutunun kararsız olduğu bir programı uygulamanıza izin verecek bir bellek ayırma işlemi vardır. Bu işleme “Dinamik bellek ayırma".

Artık bir dizi öğeyi çalışma zamanında dinamik olarak herhangi bir sorun yaşamadan oluşturabilir ve yok edebilirsiniz. Özetlemek gerekirse, otomatik bellek yönetimi yığını kullanır ve C Dinamik Bellek Ayırma yığını kullanır.

kütüphane Dinamik Bellek Yönetiminden sorumlu işlevlere sahiptir.

İşlev	Amaç
malloc ()	İstenilen boyuttaki belleği ayırır ve işaretçiyi ilk bayta döndürür. ayrılmış alan.
kalloc()	Bir dizinin elemanları için alan ayırır. Öğeleri sıfıra başlatır ve belleğe bir işaretçi döndürür.
realloc()	Daha önce ayrılmış bellek alanının boyutunu değiştirmek için kullanılır.
Özgür()	Önceden ayrılmış bellek alanını serbest bırakır veya boşaltır.

Yukarıdaki işlevleri uygulamalarıyla birlikte tartışalım

Malloc() Fonksiyonunun Sözdizimi:

ptr = (cast_type *) malloc (byte_size);

Burada,

• ptr, cast_type'ın bir işaretçisidir.
• C malloc() işlevi, ayrılmış byte_size belleğine bir işaretçi döndürür.

Malloc() örneği:

Example: ptr = (int *) malloc (50)

Bu ifade başarıyla yürütüldüğünde 50 baytlık bir bellek alanı ayrılır. Ayrılmış alanın ilk baytının adresi int tipindeki ptr işaretçisine atanır.

Başka bir örnek düşünün:

#include <stdlib.h>
int main(){
int *ptr;
ptr = malloc(15 * sizeof(*ptr)); /* a block of 15 integers */
    if (ptr != NULL) {
      *(ptr + 5) = 480; /* assign 480 to sixth integer */
      printf("Value of the 6th integer is %d",*(ptr + 5));
    }
}

Çıktı:

Value of the 6th integer is 480

1. Dikkat edin sizeof(*ptr) onun yerine kullanıldı sizeof(int) *ptr bildirimi daha sonra farklı bir veri türüne dönüştürüldüğünde kodun daha sağlam olmasını sağlamak için.
2. Bellek yeterli değilse ayırma başarısız olabilir. Bu durumda NULL işaretçisi döndürür. Bu nedenle, NULL işaretçisini kontrol etmek için kod eklemelisiniz.
3. Tahsis edilen belleğin bitişik olduğunu ve bir dizi olarak ele alınabileceğini unutmayın. Parantez [ ] kullanmak yerine dizi elemanlarına erişmek için işaretçi aritmetiğini kullanabiliriz. Dizi elemanlarına başvurmak için + kullanmanızı öneririz çünkü ++ veya += artırması, dizi tarafından depolanan adresi değiştirir. işaretçi.

Malloc() fonksiyonu karakter veri tipinin yanı sıra yapılar gibi karmaşık veri tipleriyle de kullanılabilir.

Örneğin:

#include <stdio.h>
int main() {
int* ptr = malloc(10 * sizeof(*ptr));
if (ptr != NULL){
  *(ptr + 2) = 50;
  printf("Value of the 2nd integer is %d",*(ptr + 2));
}
free(ptr);
}

Çıktı:

 Value of the 2nd integer is 50

calloc() Fonksiyonunun sözdizimi:

ptr = (cast_type *) calloc (n, size);

• Yukarıdaki ifade aynı boyuttaki n adet bellek bloğunu tahsis etmek için kullanılır.
• Bellek alanı tahsis edildikten sonra tüm baytlar sıfıra ayarlanır.
• Şu anda tahsis edilen bellek alanının ilk baytında bulunan işaretçi döndürülür.

Bellek yetersizliği gibi bellek alanı tahsisinde bir hata olduğunda, bir boş gösterici döndürülür.

Calloc() örneği:

Aşağıdaki program bir aritmetik dizinin toplamını hesaplamaktadır.

#include <stdio.h>
    int main() {
        int i, * ptr, sum = 0;
        ptr = calloc(10, sizeof(int));
        if (ptr == NULL) {
            printf("Error! memory not allocated.");
            exit(0);
        }
        printf("Building and calculating the sequence sum of the first 10 terms \ n ");
        for (i = 0; i < 10; ++i) { * (ptr + i) = i;
            sum += * (ptr + i);
        }
        printf("Sum = %d", sum);
        free(ptr);
        return 0;
    }

Sonuç:

Building and calculating the sequence sum of the first 10 terms
Sum = 45

calloc() ve malloc(): Temel Farklılıklar

Aşağıda, aralarındaki temel farklar yer almaktadır: malloc() ve calloc() C dilinde:

calloc() fonksiyonu genellikle malloc() fonksiyonundan daha uygun ve verimlidir. Her iki fonksiyon da bellek alanı ayırmak için kullanılsa da calloc() aynı anda birden fazla blok ayırabilir. Her seferinde bir bellek bloğu istemek zorunda değilsiniz. calloc() fonksiyonu daha büyük bellek alanı gerektiren karmaşık veri yapılarında kullanılır.

C'de calloc() tarafından tahsis edilen bellek bloğu her zaman sıfıra başlatılırken, C'deki malloc() işlevinde her zaman bir çöp değeri içerir.

realloc() Fonksiyonunun sözdizimi:

ptr = realloc (ptr,newsize);

Yukarıdaki ifade, newsize değişkeninde belirtilen boyutta yeni bir bellek alanı ayırır. İşlev yürütüldükten sonra işaretçi bellek bloğunun ilk baytına döndürülecektir. Yeni boyut önceki bellekten daha büyük veya daha küçük olabilir. Yeni ayrılan bloğun önceki bellek bloğuyla aynı konuma işaret edip etmeyeceğinden emin olamayız. Bu işlev, yeni bölgedeki tüm önceki verileri kopyalayacaktır. Verilerin güvende kalmasını sağlar.

realloc() örneği:

#include <stdio.h>
int main () {
   char *ptr;
   ptr = (char *) malloc(10);
   strcpy(ptr, "Programming");
   printf(" %s,  Address = %u\n", ptr, ptr);

   ptr = (char *) realloc(ptr, 20); //ptr is reallocated with new size
   strcat(ptr, " In 'C'");
   printf(" %s,  Address = %u\n", ptr, ptr);
   free(ptr);
   return 0;
}

C'deki realloc() başarısız bir işlemle sonuçlandığında, bir boş gösterici döndürür ve önceki veriler de serbest bırakılır.

#include <stdio.h>
    int main() {
        int * arr_dynamic = NULL;
        int elements = 2, i;
        arr_dynamic = calloc(elements, sizeof(int)); //Array with 2 integer blocks
        for (i = 0; i < elements; i++) arr_dynamic[i] = i;
        for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);
        elements = 4;
        arr_dynamic = realloc(arr_dynamic, elements * sizeof(int)); //reallocate 4 elements
        printf("After realloc\n");
        for (i = 2; i < elements; i++) arr_dynamic[i] = i;
        for (i = 0; i < elements; i++) printf("arr_dynamic[%d]=%d\n", i, arr_dynamic[i]);
        free(arr_dynamic);
    }

C Dynamic array programının ekrandaki sonucu:

 
arr_dynamic[0]=0
arr_dynamic[1]=1
After realloc
arr_dynamic[0]=0
arr_dynamic[1]=1
arr_dynamic[2]=2
arr_dynamic[3]=3

ÖZET

• Heap'te gerektiği gibi bellek blokları oluşturarak belleği dinamik olarak yönetebiliriz.
• C Dinamik Bellek Tahsisinde, bellek çalışma zamanında tahsis edilir.
• Dinamik bellek ayırma, boyutu esnek olan ve programınızda istediğiniz zaman değiştirilebilen dizeleri ve dizileri yönetmeye izin verir.
• Belirli bir yapının ne kadar bellek kaplayacağı hakkında hiçbir fikriniz olmadığında gereklidir.
• C'deki Malloc(), belirli boyuttaki bellek bloklarının bir çöp değerine başlatıldığı bellek ayırma anlamına gelen dinamik bir bellek ayırma işlevidir.
• C'deki Calloc(), 0'a başlatılan bir zamanda birden fazla bellek bloğunu tahsis eden bitişik bir bellek ayırma işlevidir.
• C'deki Realloc(), belleği belirtilen boyuta göre yeniden tahsis etmek için kullanılır.
• Free() işlevi dinamik olarak ayrılan belleği temizlemek için kullanılır.