Dokumentacja C z przykładami: Struktury i wskaźniki

Q: Co robi operator `->` w C?

p->x odwołuje się do pola x przez wskaźnik p. Jest to dokładny odpowiednik (*p).x: najpierw dereferencja wskaźnika, potem pobranie pola. Strzałka istnieje, bo wskaźniki na struktury są tak powszechne, że dłuższa forma zaśmiecałaby kod.

Q: Dlaczego `*p.x` nie działa dla wskaźnika na strukturę?

Bo . wiąże mocniej niż . p.x jest parsowane jako (p.x): weź pole x z p (który jest wskaźnikiem, a nie strukturą) i zrób na nim dereferencję. Potrzebujesz (p).x albo po prostu p->x.

Q: Jak zaalokować strukturę przez malloc w C?

struct Node n = malloc(sizeof n);. Forma sizeof *n pyta o rozmiar tego, na co wskazuje n, więc pozostaje poprawna, nawet jeśli później zmienisz typ. Sprawdź wynik względem NULL, zainicjalizuj każde pole, a na koniec wywołaj free(n).

Struktura przekazana do funkcji jest kopiowana. Dla punktu z dwoma liczbami int to nie problem, ale dla 200-bajtowego rekordu to marnotrawstwo, a do tego uniemożliwia zmiany, bo funkcja widzi tylko własną kopię. Wskaźnik na strukturę rozwiązuje oba problemy naraz i jest też jedynym sposobem na budowę rosnących struktur danych: list, drzew, grafów.

Pobranie wskaźnika na strukturę

Nie trzeba niczego specjalnego. & daje adres, a typ to „wskaźnik na strukturę”:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point p = {3, 4};
    struct Point *ptr = &p;

    printf("x przez strukture: %d\n", p.x);
    printf("x przez wskaznik : %d\n", (*ptr).x);
    printf("x przez strzalke : %d\n", ptr->x);
    return 0;
}

Wszystkie trzy wypisują 3. Dwa ostatnie to ta sama operacja zapisana na dwa sposoby.

Dlaczego `(*ptr).x` potrzebuje nawiasów

Może cię kusić, by je pominąć i napisać *ptr.x. To skompiluje się do czegoś zupełnie innego albo, częściej, w ogóle się nie skompiluje, bo operator pola . ma wyższy priorytet niż dereferencja *:

*ptr.x        // parsowane jako *(ptr.x): zle
(*ptr).x      // najpierw dereferencja, potem pole: poprawnie
ptr->x        // to samo, krocej

ptr.x prosi o pole wskaźnika, a wskaźnik nie ma pól. Komunikat kompilatora („request for member 'x' in something not a structure or union”) to przebrany błąd priorytetu.

Ponieważ forma z nawiasami jest brzydka i łatwo o pomyłkę, C daje ->. W praktyce prawie nigdy nie zobaczysz (*p).x w prawdziwym kodzie: sięgaj po p->x i zapomnij o długiej formie, poza tym, że wyjaśnia, co znaczy strzałka.

Przekazywanie struktury przez wskaźnik

Parametr wskaźnikowy daje funkcji prawdziwą strukturę wywołującego, więc zmiany zostają:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

/* Zmienia strukture wywolujacego. */
void translate(struct Point *p, int dx, int dy) {
    p->x += dx;
    p->y += dy;
}

/* Tylko czyta: mowi to const, a kompilator tego pilnuje. */
void print_point(const struct Point *p) {
    printf("(%d, %d)\n", p->x, p->y);
}

int main(void) {
    struct Point p = {3, 4};

    print_point(&p);
    translate(&p, 10, -2);
    print_point(&p);
    return 0;
}

Dwa nawyki, które warto tu wyrobić:

Oznaczaj wskaźniki tylko do odczytu jako const. const struct Point *p obiecuje, że funkcja nie zmieni tego, na co wskazuje p. Jeśli ktoś później doda w środku p->x = 0, kompilacja się nie uda, zamiast błąd trafić na produkcję. To także dokumentuje intencję w miejscu wywołania.
Przekazuj wskaźnik przy dużych strukturach, nawet gdy tylko czytasz. Struktura z 64-bajtowym buforem na nazwę kosztuje 64 bajty kopiowania przy każdym wywołaniu przez wartość, a wskaźnik 8.

Małe struktury nadal można spokojnie przekazywać przez wartość: 8-bajtowe struct Point kopiuje się równie tanio jak wskaźnik, a wersja przez wartość nie może być NULL, co usuwa cały rodzaj awarii.

Wskaźniki do tablic struktur

Arytmetyka wskaźników działa na tablicach struktur dokładnie tak jak na tablicach int: p + 1 przesuwa się o całą strukturę, łącznie z wyrównaniem.

#include <stdio.h>

struct Employee {
    int id;
    char name[16];
    double salary;
};

double total_payroll(const struct Employee *staff, int n) {
    double total = 0.0;
    for (const struct Employee *e = staff; e < staff + n; e++) {
        total += e->salary;
    }
    return total;
}

int main(void) {
    struct Employee staff[] = {
        {101, "Ada",   92000.0},
        {102, "Grace", 105000.0},
        {103, "Alan",  87000.0},
    };
    int n = sizeof(staff) / sizeof(staff[0]);

    printf("Suma wynagrodzen: %.2f\n", total_payroll(staff, n));
    return 0;
}

Nazwa tablicy zamienia się we wskaźnik na jej pierwszy element, więc w miejscu wywołania staff już jest struct Employee *. Dlatego funkcja potrzebuje też osobno przekazanego n: sizeof wewnątrz funkcji zmierzyłby wskaźnik, a nie tablicę.

Alokacja struktury na stercie

Struktury na stosie umierają na końcu swojego zasięgu. Aby utworzyć taką, która przeżyje funkcję, w której powstała, albo utworzyć ich tyle, ile wymaga wejście, zaalokuj ją przez malloc:

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

struct Employee {
    int id;
    char name[16];
    double salary;
};

struct Employee *make_employee(int id, const char *name, double salary) {
    struct Employee *e = malloc(sizeof *e);
    if (e == NULL) {
        return NULL;            /* brak pamieci: wywolujacy musi to sprawdzic */
    }
    e->id = id;
    snprintf(e->name, sizeof e->name, "%s", name);
    e->salary = salary;
    return e;
}

int main(void) {
    struct Employee *e = make_employee(101, "Ada", 92000.0);
    if (e == NULL) {
        fprintf(stderr, "alokacja nie powiodla sie\n");
        return 1;
    }

    printf("%d %s %.2f\n", e->id, e->name, e->salary);

    free(e);
    return 0;
}

W tej małej funkcji każdy z czterech szczegółów jest nośny:

sizeof *e, a nie sizeof(struct Employee). Czyta się to jako „rozmiar tego, na co wskazuje e”, więc jeśli typ kiedyś się zmieni, alokacja automatycznie za nim pójdzie. Te dwie rzeczy nie mogą się rozjechać.
Sprawdzaj NULL. malloc zwraca NULL, gdy nie może spełnić żądania. Zapis e->id przez wskaźnik null to segmentation fault.
Inicjalizuj każde pole. malloc nie zeruje pamięci, struktura przychodzi pełna śmieci. (calloc(1, sizeof *e) wyzeruje ją za ciebie.)
Ktoś musi wywołać free. Zwrócenie zaalokowanego wskaźnika przenosi ten obowiązek na wywołującego. Napisz to w komentarzu: niejasna zasada własności to początek wycieków pamięci.

Nagroda: węzeł listy wiązanej

Oto coś, czego struktury nie potrafią bez wskaźników. Struktura nie może zawierać samej siebie, bo byłaby nieskończenie duża, ale może zawierać wskaźnik na strukturę tego samego rodzaju, a ta jedna sztuczka buduje każdą wiązaną strukturę danych w C.

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

struct Node {
    int value;
    struct Node *next;     /* wskaznik na ten sam typ jest w porzadku */
};

/* Dodaje wezel na poczatek i zwraca nowa glowe. */
struct Node *push(struct Node *head, int value) {
    struct Node *n = malloc(sizeof *n);
    if (n == NULL) {
        return head;       /* brak pamieci: lista bez zmian */
    }
    n->value = value;
    n->next = head;
    return n;
}

void print_list(const struct Node *head) {
    for (const struct Node *n = head; n != NULL; n = n->next) {
        printf("%d -> ", n->value);
    }
    printf("NULL\n");
}

void free_list(struct Node *head) {
    while (head != NULL) {
        struct Node *next = head->next;   /* zapamietaj przed zwolnieniem */
        free(head);
        head = next;
    }
}

int main(void) {
    struct Node *head = NULL;

    head = push(head, 3);
    head = push(head, 2);
    head = push(head, 1);

    print_list(head);
    free_list(head);
    return 0;
}

Zauważ, że struct Node *next; odwołuje się do struct Node, zanim deklaracja struct Node się skończy. Jest to dozwolone właśnie dlatego, że wskaźnik ma znany rozmiar niezależnie od tego, na co wskazuje, więc kompilator nie potrzebuje jeszcze pełnej definicji. To także jedyne miejsce, gdzie musisz użyć etykiety struct Node, nawet jeśli istnieje też typedef: nazwa z typedef nie istnieje jeszcze wewnątrz własnej definicji.

Pętla free_list zapamiętuje head->next przed wywołaniem free(head). Odczyt head->next po zwolnieniu to użycie po zwolnieniu (use-after-free): pamięć już nie należy do ciebie, a odczytana wartość to cokolwiek zostawił tam alokator.

Częste błędy

p->x na niezainicjalizowanym wskaźniku lub NULL. Najczęstsza przyczyna awarii w kodzie pełnym struktur. Inicjalizuj wskaźniki wartością NULL i sprawdzaj je przed dereferencją.
Zwracanie wskaźnika na lokalną strukturę. struct Point *bad(void) { struct Point p = {1,2}; return &p; } zwraca adres pamięci, która przestaje istnieć w chwili powrotu z funkcji. Zwróć strukturę przez wartość albo ją zaalokuj.
Podwójne zwolnienie albo brak zwolnienia. Każde malloc łączy się z dokładnie jednym free. Po zwolnieniu ustaw wskaźnik na NULL, żeby późniejsze przypadkowe użycie wysypało program głośno, zamiast po cichu psuć pamięć.
Kopiowanie struktury, która zawiera wskaźnik. Przypisanie struktury kopiuje wartość wskaźnika, a nie to, na co on wskazuje. Obie struktury odwołują się wtedy do tego samego bufora, a ta, która zwolni go pierwsza, zostawia drugą z wiszącym wskaźnikiem.

Najczęściej zadawane pytania

Co robi operator -> w C?

p->x odwołuje się do pola x przez wskaźnik p. Jest to dokładny odpowiednik (*p).x: najpierw dereferencja wskaźnika, potem pobranie pola. Strzałka istnieje, bo wskaźniki na struktury są tak powszechne, że dłuższa forma zaśmiecałaby kod.

Dlaczego *p.x nie działa dla wskaźnika na strukturę?

Bo . wiąże mocniej niż *. *p.x jest parsowane jako *(p.x): weź pole x z p (który jest wskaźnikiem, a nie strukturą) i zrób na nim dereferencję. Potrzebujesz (*p).x albo po prostu p->x.

Przekazywać strukturę przez wartość czy przez wskaźnik w C?

Przez wskaźnik, gdy funkcja musi zmienić strukturę wywołującego albo gdy struktura jest duża i kopiowanie byłoby marnotrawstwem. Przez wartość w przypadku małych struktur tylko do odczytu, gdzie kopia jest tania, a kod prostszy. Parametry wskaźnikowe tylko do odczytu oznaczaj jako const struct T *, aby kompilator pilnował tej obietnicy.

Jak zaalokować strukturę przez malloc w C?

struct Node *n = malloc(sizeof *n);. Forma sizeof *n pyta o rozmiar tego, na co wskazuje n, więc pozostaje poprawna, nawet jeśli później zmienisz typ. Sprawdź wynik względem NULL, zainicjalizuj każde pole, a na koniec wywołaj free(n).

Powiązane zagadnienia