C Academy · Lekcja

malloc i free

Alokowanie na stercie

malloc i free to bezpłatna lekcja C Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C Academy zawiera 4 lekcji w sumie.

Sterta

Do tej pory zmienne znajdowały się na stosie i miały stały czas życia. Sterta pozwala żądać pamięci w czasie działania programu i przechowywać dane tak długo, jak jest to potrzebne.

Pamięcią sterty zarządza się samodzielnie za pomocą funkcji z <stdlib.h>.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 99;
    printf("%d\n", *p);
    free(p);
    return 0;
}

Wywoływanie malloc

malloc(size) rezerwuje size bajtów i zwraca wskaźnik do nich lub NULL w razie niepowodzenia.

Pamięć jest niezainicjalizowana: jej zawartość jest nieokreślona.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 7;
    printf("value = %d\n", *p);
    free(p);
    return 0;
}

Określanie rozmiaru za pomocą sizeof

Zawsze określaj rozmiar alokacji za pomocą sizeof, aby kod działał poprawnie na każdej platformie.

Zapis sizeof(*p) automatycznie wiąże rozmiar z typem wskaźnika.

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

int main(void) {
    double *p = malloc(sizeof(*p));
    *p = 3.14;
    printf("%f\n", *p);
    free(p);
    return 0;
}

Zawsze sprawdzaj NULL

Jeśli alokacja się nie powiedzie, malloc zwraca NULL. Wyłuskanie tego wskaźnika powoduje awarię programu.

Przed użyciem sprawdź wynik.

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

int main(void) {
    int *p = malloc(sizeof(int));
    if (p == NULL) {
        printf("allocation failed\n");
        return 1;
    }
    *p = 5;
    printf("ok: %d\n", *p);
    free(p);
    return 0;
}

Alokowanie tablicy

Aby przechować wiele elementów, pomnóż rozmiar elementu przez ich liczbę.

malloc(n * sizeof(int)) tworzy miejsce na n liczb całkowitych.

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

int main(void) {
    int n = 5;
    int *arr = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) arr[i] = i * i;
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    free(arr);
    return 0;
}

Tablice na stercie używają indeksowania wskaźnikiem

Do tablicy na stercie uzyskuje się dostęp przez jej wskaźnik za pomocą znanej składni arr[i], która jest równoważna *(arr + i).

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

int main(void) {
    int *arr = malloc(3 * sizeof(int));
    arr[0] = 10;
    *(arr + 1) = 20;
    arr[2] = 30;
    printf("%d %d %d\n", arr[0], arr[1], arr[2]);
    free(arr);
    return 0;
}

Zwalnianie pamięci

free(p) zwraca blok do alokatora. Po tej operacji nie wolno używać p do uzyskiwania dostępu do tej pamięci.

Każde pomyślne wywołanie malloc wymaga odpowiadającego mu wywołania free.

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

int main(void) {
    char *buf = malloc(16);
    if (buf) {
        buf[0] = 'A';
        printf("%c\n", buf[0]);
        free(buf);
    }
    return 0;
}

free(NULL) jest bezpieczne

Wywołanie free dla wskaźnika NULL nic nie robi i jest całkowicie dozwolone.

Upraszcza to kod sprzątający, który może zostać wykonany przed pomyślnym zakończeniem alokacji.

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

int main(void) {
    int *p = NULL;
    free(p);
    printf("free(NULL) was safe\n");
    return 0;
}

Zwracanie pamięci ze sterty

W przeciwieństwie do zmiennych na stosie pamięć na stercie pozostaje dostępna po zakończeniu funkcji. Dzięki temu funkcja może zaalokować bufor i zwrócić go.

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

int *make_range(int n) {
    int *a = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) a[i] = i;
    return a;
}

int main(void) {
    int *r = make_range(4);
    printf("%d %d\n", r[0], r[3]);
    free(r);
    return 0;
}

Nie rzutuj malloc w języku C

W języku C malloc zwraca wartość typu void *, która jest automatycznie konwertowana na dowolny typ wskaźnikowy.

Rzutowanie jest niepotrzebne i może ukryć brak dołączenia <stdlib.h>.

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

int main(void) {
    long *p = malloc(sizeof(long));
    *p = 1234567L;
    printf("%ld\n", *p);
    free(p);
    return 0;
}

Nie zwalniaj pamięci dwukrotnie

Wywołanie free dwa razy dla tego samego wskaźnika jest niezdefiniowanym zachowaniem i może uszkodzić stertę.

Po zwolnieniu ustaw wskaźnik na NULL, aby przypadkowe ponowne użycie nie powodowało problemów.

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 1;
    free(p);
    p = NULL;
    free(p);
    printf("no double free\n");
    return 0;
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat malloc i free.

Podsumowanie

Poznałeś podstawy alokowania pamięci na stercie:

malloc(size) rezerwuje niezainicjalizowane bajty, zwracając NULL w razie niepowodzenia.
Zawsze sprawdzaj wynik i określaj rozmiar za pomocą sizeof.
free(p) zwraca pamięć; każdemu wywołaniu malloc musi odpowiadać jedno wywołanie free.
free(NULL) jest bezpieczne; podwójne zwolnienie pamięci jest niezdefiniowane.

Często zadawane pytania

Czy lekcja „malloc i free” jest bezpłatna?

Tak — pełny tekst „malloc i free” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C Academy, przejdź na CoddyKit PRO. Kurs C Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „malloc i free”?

Alokowanie na stercie Ćwiczysz C Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C Academy?

Nie wymagamy żadnego doświadczenia. C Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „malloc i free”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C Academy?

Tak. Każda lekcja C Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C Academy