Dokumentacja C z przykładami: calloc i realloc

Q: Jaka jest różnica między calloc a malloc w C?

Są dwie różnice. calloc(n, size) przyjmuje liczbę elementów i rozmiar elementu osobno i sprawdza, czy ich iloczyn się nie przepełnia, a malloc(n * size) może się po cichu przekręcić. Poza tym calloc wypełnia blok zerami, a malloc zostawia w nim to, co było tam wcześniej.

Q: Jak działa realloc w C?

realloc(p, newsize) zwraca blok o nowym rozmiarze z zachowaną dotychczasową zawartością, do mniejszego z dwóch rozmiarów. Może powiększyć blok w miejscu albo go przenieść, więc jedynym wskaźnikiem, którego możesz dalej używać, jest ten zwrócony: stary mógł już zostać zwolniony.

Q: Dlaczego wynik realloc trzeba przypisać do tymczasowego wskaźnika?

Bo p = realloc(p, n) nadpisuje p wartością NULL, gdy wywołanie się nie powiedzie, a oryginalny blok nadal jest zaalokowany i nic na niego nie wskazuje: to wyciek. Przypisz najpierw do tmp, sprawdź, czy nie jest NULL, i dopiero wtedy napisz p = tmp.

malloc odpowiada na jedno pytanie: daj mi tyle bajtów. Dwie towarzyszące mu funkcje z <stdlib.h> odpowiadają na kolejne pytania: daj mi tyle bajtów, wyczyszczonych (calloc) oraz potrzebuję, żeby blok, który już mam, był większy (realloc).

calloc: liczba, rozmiar i zera

void *calloc(size_t count, size_t size);

Dwa argumenty zamiast jednego, a wynik jest wypełniony bajtami zerowymi.

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

int main(void) {
    size_t n = 6;

    int *counts = calloc(n, sizeof *counts);
    if (counts == NULL) {
        fprintf(stderr, "brak pamieci\n");
        return 1;
    }

    /* już wyzerowane: pętla inicjalizująca nie jest potrzebna */
    for (size_t i = 0; i < n; i++) {
        printf("%d ", counts[i]);
    }
    printf("\n");

    counts[2] += 1;
    counts[2] += 1;
    printf("counts[2] = %d\n", counts[2]);

    free(counts);
    return 0;
}

To klasyczny przypadek: histogram albo tablica liczników, w której każde pole musi zaczynać od zera. Z malloc potrzebna byłaby pętla; calloc robi to w ramach alokacji, często za darmo, bo system operacyjny i tak wydaje świeże strony pamięci już wyzerowane.

Argument o przepełnieniu

Podział na dwa argumenty nie jest kosmetyczny. Weźmy liczbę elementów odczytaną z pliku:

size_t n = huge_value_from_input;

int *a = malloc(n * sizeof *a);     /* iloczyn może się przekręcić */
int *b = calloc(n, sizeof *b);      /* musi wykryć przepełnienie */

Jeśli n * sizeof *a przekroczy to, co mieści size_t, wynik przekręca się do małej liczby, malloc kończy się sukcesem z malutkim blokiem, a każdy kolejny zapis wychodzi daleko za jego koniec. Standard wymaga, żeby calloc w takiej sytuacji zawiódł i zwrócił NULL. Gdy rozmiar pochodzi spoza twojego programu, to sprawdzenie jest warte zachodu.

Co naprawdę znaczy "wyzerowane"

calloc zapisuje zerowe bajty. Dla liczb całkowitych i znaków to wartość zero, czyli to, czego chcesz. Dla wskaźników i liczb zmiennoprzecinkowych wszystkie bity równe zero to wskaźnik pusty i 0.0 na każdej popularnej platformie, ale standard C tego nie obiecuje. Kod, który musi być ściśle przenośny, przypisuje te wartości jawnie.

calloc a malloc + memset

int *a = calloc(n, sizeof *a);

int *b = malloc(n * sizeof *b);
if (b != NULL) {
    memset(b, 0, n * sizeof *b);
}

Dają ten sam wynik. Wybieraj calloc: to jedna linia, robi sprawdzenie przepełnienia, a przy dużych blokach może w ogóle nie dotykać pamięci. Wybieraj zwykły malloc, gdy i tak zaraz nadpiszesz każdy bajt: zerowanie megabajta, który zaraz wypełnisz, to czyste marnotrawstwo.

realloc: zmiana rozmiaru

void *realloc(void *p, size_t newsize);

realloc zwraca blok o rozmiarze newsize bajtów, którego zawartość zgadza się ze starym blokiem do mniejszego z dwóch rozmiarów. Może rozszerzyć blok tam, gdzie leży, albo zaalokować nowy, skopiować dane i zwolnić stary. Nie da się stwierdzić, co zrobił, więc jedynym wskaźnikiem, którego możesz potem używać, jest ten, który zwrócił.

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

int main(void) {
    size_t n = 3;
    int *a = malloc(n * sizeof *a);
    if (a == NULL) {
        return 1;
    }
    for (size_t i = 0; i < n; i++) {
        a[i] = (int)i;
    }

    size_t bigger = 6;
    int *tmp = realloc(a, bigger * sizeof *a);
    if (tmp == NULL) {
        free(a);                 /* a nadal jest ważny: zwolnij go */
        fprintf(stderr, "nie udalo sie powiekszyc\n");
        return 1;
    }
    a = tmp;

    /* pierwsze 3 wartości przetrwały; nowe pola nie są zainicjalizowane */
    for (size_t i = n; i < bigger; i++) {
        a[i] = (int)(i * 10);
    }

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

    free(a);
    return 0;
}

Idiom ze wskaźnikiem tmp

Trzy linie wokół tmp to cały powód, dla którego ta funkcja ma swoją reputację. Kuszący skrót jest błędny:

/* BUG: gubi oryginalny blok (wyciek), gdy realloc zawiedzie */
p = realloc(p, newsize);
if (p == NULL) {
    return;
}

Gdy realloc zawodzi, zwraca NULL i zostawia oryginalny blok zaalokowany i niezmieniony. Przypisanie wyniku prosto do p nadpisuje jedyny wskaźnik na ten blok, więc nie da się go już zwolnić: to wyciek, i to taki, który zdarza się dokładnie wtedy, gdy pamięci już brakuje. Przypisz do tmp, sprawdź tmp, a potem zatwierdź:

void *tmp = realloc(p, newsize);
if (tmp == NULL) {
    /* p nadal jest ważny; obsłuż błąd tak, jak pasuje wywołującemu */
    return 0;
}
p = tmp;

Dwa kolejne zachowania warte poznania: realloc(NULL, n) działa dokładnie jak malloc(n), dzięki czemu funkcja powiększająca obsłuży pierwsze wywołanie bez specjalnego przypadku. Poza tym przy powiększaniu nowe bajty pozostają niezainicjalizowane: zachowywana jest tylko stara zawartość.

Powiększanie tablicy: standardowy wzorzec

Oto wzorzec, którego używa prawie każdy kontener w C: długość, pojemność i podwajanie, gdy się zrównają.

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

struct IntVec {
    int   *data;
    size_t len;
    size_t cap;
};

/* zwraca 1 przy sukcesie, 0 jeśli tablicy nie dało się powiększyć */
int vec_push(struct IntVec *v, int value) {
    if (v->len == v->cap) {
        size_t newcap = (v->cap == 0) ? 4 : v->cap * 2;

        int *tmp = realloc(v->data, newcap * sizeof *v->data);
        if (tmp == NULL) {
            return 0;               /* v->data jest nietknięte i nadal ważne */
        }
        v->data = tmp;
        v->cap  = newcap;
    }

    v->data[v->len++] = value;
    return 1;
}

int main(void) {
    struct IntVec v = {NULL, 0, 0};

    for (int i = 1; i <= 10; i++) {
        if (!vec_push(&v, i * i)) {
            fprintf(stderr, "brak pamieci przy %d\n", i);
            free(v.data);
            return 1;
        }
    }

    printf("len = %zu, cap = %zu\n", v.len, v.cap);
    for (size_t i = 0; i < v.len; i++) {
        printf("%d ", v.data[i]);
    }
    printf("\n");

    free(v.data);
    v.data = NULL;
    v.len = v.cap = 0;
    return 0;
}

Całą robotę wykonują tu dwie decyzje projektowe.

Podwajanie, a nie dodawanie jednego. Powiększanie o stałą wartość sprawia, że każde dodanie kopiuje całą tablicę, więc wypełnienie n elementów kosztuje mniej więcej n² kopiowań. Podwajanie sprawia, że kopiowania są na tyle rzadkie, że każde dodanie kosztuje średnio stały czas. Start cap == 0 ? 4 : cap * 2 obsługuje pierwsze dodanie bez osobnej gałęzi, bo realloc(NULL, n) to po prostu malloc.

Struktura jest właścicielem jednej alokacji. v.data jest zwalniane dokładnie raz, przez tego, kto jest właścicielem struktury. Zapisanie tej reguły własności, w komentarzu albo przez łączenie każdego vec_init z vec_free, to właśnie to, co chroni rosnący kontener przed wyciekiem, gdy wędruje między funkcjami.

Zmniejszanie

realloc z mniejszym rozmiarem przycina blok, co przydaje się po wczytaniu nieznanej ilości danych do zbyt dużego bufora:

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

int main(void) {
    size_t cap = 1024;
    char *buf = malloc(cap);
    if (buf == NULL) {
        return 1;
    }

    const char *text = "tylko kilka bajtow";
    size_t used = 0;
    while (text[used] != '\0' && used < cap - 1) {
        buf[used] = text[used];
        used++;
    }
    buf[used] = '\0';

    char *tmp = realloc(buf, used + 1);
    if (tmp != NULL) {
        buf = tmp;               /* zmniejszenie się udało */
    }
    /* jeśli się nie udało, buf to nadal większy blok, w pełni użyteczny */

    printf("[%s] teraz ma rozmiar %zu\n", buf, used + 1);

    free(buf);
    return 0;
}

Nieudane zmniejszenie nie jest błędem, dla którego warto przerywać program: stary, większy blok nadal jest ważny i nadal poprawny. To jedyny przypadek, w którym zignorowanie błędu jest właściwą decyzją, ale zauważ, że i tak idzie to przez tmp, bo reguła o nienadpisywaniu żywego wskaźnika się nie zmienia.

Po co sięgnąć

Potrzebujesz	Użyj
Bajtów, zawartość bez znaczenia	`malloc(n * sizeof *p)`
Określonej liczby elementów, wyzerowanych	`calloc(n, sizeof *p)`
Liczby elementów z niezaufanego wejścia	`calloc`, ze względu na sprawdzenie przepełnienia
Bloku, który już masz, większego albo mniejszego	`realloc` przez wskaźnik `tmp`
Pierwszej alokacji w pętli powiększania	`realloc(NULL, n)`: bez specjalnego przypadku

Wszystkie cztery zwalnia ten sam free, dokładnie raz.

Częste błędy

p = realloc(p, n): wyciek przy niepowodzeniu. Zawsze idź przez tmp.
Trzymanie starego wskaźnika do wnętrza bloku. Po realloc dane mogły się przenieść, więc każdy zapamiętany wskaźnik do środka bloku czy adres wyliczony z indeksu jest nieaktualny. Indeksy przetrwają przeprowadzkę; wskaźniki nie.
Założenie, że nowe bajty są zerami. Zeruje tylko calloc. realloc zostawia dodany obszar niezainicjalizowany.
calloc(n * size, 1): to wyrzuca sprawdzenie przepełnienia, dla którego istnieje forma z dwoma argumentami.
Zwalnianie starego wskaźnika po udanym realloc. realloc już go zwolnił; drugi free to podwójne zwolnienie.

Najczęściej zadawane pytania

Jaka jest różnica między calloc a malloc w C?

Są dwie różnice. calloc(n, size) przyjmuje liczbę elementów i rozmiar elementu osobno i sprawdza, czy ich iloczyn się nie przepełnia, a malloc(n * size) może się po cichu przekręcić. Poza tym calloc wypełnia blok zerami, a malloc zostawia w nim to, co było tam wcześniej.

Jak działa realloc w C?

realloc(p, newsize) zwraca blok o nowym rozmiarze z zachowaną dotychczasową zawartością, do mniejszego z dwóch rozmiarów. Może powiększyć blok w miejscu albo go przenieść, więc jedynym wskaźnikiem, którego możesz dalej używać, jest ten zwrócony: stary mógł już zostać zwolniony.

Dlaczego wynik realloc trzeba przypisać do tymczasowego wskaźnika?

Bo p = realloc(p, n) nadpisuje p wartością NULL, gdy wywołanie się nie powiedzie, a oryginalny blok nadal jest zaalokowany i nic na niego nie wskazuje: to wyciek. Przypisz najpierw do tmp, sprawdź, czy nie jest NULL, i dopiero wtedy napisz p = tmp.

Kiedy używać calloc zamiast malloc?

Gdy naprawdę potrzebujesz wyzerowanej pamięci (tablica liczników, struktura, której pola mają zaczynać puste, bufor, który wypełnisz częściowo) albo gdy rozmiar to liczba elementów razy rozmiar elementu, która może być duża. Jeśli i tak nadpiszesz każdy bajt, malloc oszczędzi ci pracy zerowania.

Powiązane zagadnienia