C'de malloc: Dinamik Bellek Tahsisi, free ve sizeof

Şimdiye kadar yazdığınız her dizinin boyutu derleme zamanında pişirilmişti: int scores[10];, üçe de üç yüze de ihtiyacınız olsa on yuva ayırır. Bu, boyut yalnızca program çalışırken bilinene dek işe yarar - bir dosyanın kaç satırı olduğu, kullanıcının kaç kayıt girdiği. Dinamik bellek bunu çözer: ihtiyacınız olan baytları, ihtiyacınız olduğunda istersiniz ve işiniz bitince geri verirsiniz.

Araçlar <stdlib.h> içindedir:

#include <stdlib.h>

Öbek Neden Var

C, programınıza iki ana bellek bölgesi verir. Yerel değişkenler otomatik depolamada (yığın/stack) yaşar: boyutlarına derleyici karar verir ve fonksiyonları döndüğü anda yok olurlar. Dinamik tahsisler öbekte (heap) yaşar: boyuta çalışma zamanında siz karar verirsiniz ve blok, siz açıkça serbest bırakana dek canlı kalır.

O ikinci özellik, malloc kullanmanın asıl sebebidir. Bir fonksiyon bir blok tahsis edip göstericiyi döndürebilir ve bellek çağıranda hâlâ geçerlidir - yerel bir dizinin asla yapamayacağı bir şey. İki bölge ayrıntılı olarak yığın ve öbek sayfasında karşılaştırılıyor.

malloc: Bayt İstemek

malloc bir bayt sayısı alır ve o kadar ilk değersiz belleğe işaret eden bir void * döndürür; istek başarısız olursa NULL döndürür.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n = 5;

    int *scores = malloc(n * sizeof *scores);
    if (scores == NULL) {
        fprintf(stderr, "bellek yetersiz\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        scores[i] = (i + 1) * 10;
    }

    for (int i = 0; i < n; i++) {
        printf("scores[%d] = %d\n", i, scores[i]);
    }

    free(scores);
    scores = NULL;
    return 0;
}

O kısa programdaki dört şey disiplinin tamamıdır:

1. Boyut ifadesi n * sizeof *scores'tur. Bunu "scores neyi gösteriyorsa ondan n tane" diye okuyun.
2. Sonuç, herhangi bir kullanımdan önce NULL ile karşılaştırılır.
3. Blok tam olarak bir dizi gibi kullanılır - scores[i] çalışır, çünkü indeksleme gösterici aritmetiğidir.
4. Bir kez serbest bırakılır ve gösterici ardından NULL yapılır.

Dönüş değerinde dönüşüm olmadığına dikkat edin. C'de void * her nesne göstericisine otomatik dönüşür ve (int *)malloc(...) yazmak gürültü eklerken eksik bir <stdlib.h> include'unu gizler. (C++ dönüşümü ister; C istemez.)

sizeof Deyimi

Neden sizeof(int) değil de sizeof *scores? Çünkü bayatlayamaz.

int  *a = malloc(n * sizeof *a);     /* n adet int, int burada neyse */
long *b = malloc(n * sizeof *b);     /* aynı satır biçimi, doğru boyut */

/* kırılgan biçim */
long *c = malloc(n * sizeof(int));   /* derlenir, çok az tahsis eder */

Son satır, hiçbir derleyicinin uyarmadığı gerçek bir hatadır: c bir long *'dır, tahsis int için boyutlanmıştır ve ilk yarıdan sonraki her yazma sonun dışına taşar. sizeof *c ile boyut bildirimi otomatik izler.

sizeof *p, p'yi dereferans etmez - sizeof yalnızca tipten, derleme zamanında değerlendirilir, dolayısıyla p ilk değersiz ya da NULL olduğunda bile güvenlidir.

İlk Değersiz Bellek

malloc size verdiğini temizlemez. Baytlar daha önce orada ne varsa onu tutar.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(4 * sizeof *p);
    if (p == NULL) {
        return 1;
    }

    /* yazmadan once okumak tanimsiz davranistir - o yuzden once yaz */
    for (int i = 0; i < 4; i++) {
        p[i] = 0;
    }

    printf("%d %d %d %d\n", p[0], p[1], p[2], p[3]);

    free(p);
    return 0;
}

Bloğun sizin için sıfırlanmasını istediğinizde calloc bunu tek adımda yapar - bkz. calloc ve realloc.

free: Geri Vermek

free(p) bloğu tahsis ediciye geri verir. Üç kural:

• malloc'un döndürdüğü tam göstericiyi geçirin, ilerletilmiş birini değil. free(p + 1) tanımsız davranıştır.
• Her bloğu tam olarak bir kez serbest bırakın. İki kez, tahsis edicinin kendi kayıtlarını bozan bir çifte serbest bırakmadır.
• Serbest bıraktıktan sonra gösterici bayattır. Onu kullanmak bir serbest-bırakma-sonrası-kullanımdır.

int *p = malloc(sizeof *p);
free(p);
*p = 5;        /* serbest-bırakma-sonrası-kullanım - tanımsız davranış */
free(p);       /* çifte serbest bırakma - tanımsız davranış */

Hiçbir satırın hemen çökmesi gerekmez, tehlikeli kılan da budur: program dakikalarca çalışıp sonra alakasız bir yerde başarısız olabilir. Ucuz savunma, göstericiyi boşaltmaktır:

free(p);
p = NULL;

free(NULL)'ın hiçbir şey yapmadığı açıkça tanımlıdır, dolayısıyla ondan sonraki ikinci bir free(p) zararsızdır ve *p, sessiz bozulma yerine gerçek hata noktasında anlık bir çökmeye dönüşür.

Baştan Sona Bir Dinamik Dizi

İşte gerçek bir tahsisin biçimi: çalışma zamanında bir sayı oku, bloğu ondan boyutlandır, kullan, serbest bırak.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n = 8;   /* bunun girdiden ya da bir dosyadan geldigini varsayin */

    double *values = malloc((size_t)n * sizeof *values);
    if (values == NULL) {
        fprintf(stderr, "%d double tahsisi basarisiz\n", n);
        return 1;
    }

    for (int i = 0; i < n; i++) {
        values[i] = 1.0 / (i + 1);
    }

    double sum = 0.0;
    for (int i = 0; i < n; i++) {
        sum += values[i];
    }

    printf("1/1 .. 1/%d toplami = %f\n", n, sum);
    printf("blok %zu bayt tutuyor\n", (size_t)n * sizeof *values);

    free(values);
    values = NULL;
    return 0;
}

Sayıdaki size_t dönüşümü, boyutlar büyüdüğünde önem kazanır: düz bir int n ile n * sizeof *values, çarpma malloc'a ulaşmadan taşabilir ve amaçlanandan çok daha küçük bir blok üretebilir. size_t içinde çarpmak bunu önler.

Bir Fonksiyonun İçinde Tahsis

Öbeğin ömür kuralı, bunu geçerli - ve yerel bir dizi döndürmeyi geçersiz - kılan şeydir:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* dondurulen blogun sahibi cagirandir ve onu free etmelidir */
char *duplicate(const char *text) {
    size_t len = strlen(text);
    char *copy = malloc(len + 1);
    if (copy == NULL) {
        return NULL;
    }
    memcpy(copy, text, len + 1);
    return copy;
}

int main(void) {
    char *greeting = duplicate("merhaba, obek");
    if (greeting == NULL) {
        fprintf(stderr, "bellek yetersiz\n");
        return 1;
    }

    greeting[0] = 'M';
    printf("%s\n", greeting);

    free(greeting);
    return 0;
}

len + 1, boş sonlandırıcı için yer bırakır - metinlerdeki her yerdeki boyutlandırma kuralının aynısı. Ve fonksiyonun üstündeki yoruma dikkat edin: bir fonksiyon tahsis edilmiş bellek döndürdüğünde, onu kimin serbest bırakacağı sözleşmesinin bir parçasıdır. Bunu yazıya dökmek evrak işi değildir; bir sızıntıyı önleyen tek şeydir.

Öbekteki Yapılar

Aynı deyim her tür için çalışır:

#include <stdio.h>
#include <stdlib.h>

struct Point {
    double x;
    double y;
};

int main(void) {
    struct Point *p = malloc(sizeof *p);
    if (p == NULL) {
        return 1;
    }

    p->x = 3.0;
    p->y = 4.0;
    printf("(%.1f, %.1f)\n", p->x, p->y);

    /* onlardan bir dizi */
    int n = 3;
    struct Point *path = malloc((size_t)n * sizeof *path);
    if (path == NULL) {
        free(p);
        return 1;
    }

    for (int i = 0; i < n; i++) {
        path[i].x = i;
        path[i].y = i * i;
    }
    printf("son nokta: (%.1f, %.1f)\n", path[n - 1].x, path[n - 1].y);

    free(path);
    free(p);
    return 0;
}

İkinci başarısızlık dalının, dönmeden önce p'yi serbest bıraktığına dikkat edin. Bir fonksiyon birden fazla tahsis tuttuğunda, her hata yolunun çoktan alınmış olanları serbest bırakması gerekir - bellek sızıntıları sayfasında anlatılan sızıntıların en yaygın kaynağı.

Kontrol Listesi

• İlk kullanımdan önce malloc'u her zaman NULL için kontrol edin.
• n * sizeof *p ile, size_t içinde çarparak boyutlandırın.
• C'de dönüş değerinde dönüşüm yoktur.
• malloc belleği ilk değersizdir; okumadan önce yazın.
• Tam olarak bir kez, özgün göstericiyle serbest bırakın, sonra NULL yapın.
• Bir tahsisten sonraki her hata yolu, çoktan tuttuklarını serbest bırakmalıdır.