Zmienne w C: deklaracja, inicjalizacja i przypisanie

Zmienna to nazwany fragment pamięci, który przechowuje wartość, a program może ją odczytywać i zmieniać. W C zawsze z góry określasz, jaki rodzaj wartości przechowuje zmienna, i ten wybór obowiązuje przez cały czas jej życia.

Deklaracja zmiennej

Forma to typ, nazwa, średnik:

int age;
double price;
char grade;

Każda linia rezerwuje tyle pamięci, ile potrzebuje dany typ danych, i nadaje jej nazwę. Nic jeszcze nie zostało zapisane: miejsce istnieje, ale jego zawartość to to, co zostawił tam wcześniej uruchomiony kod.

Wartość możesz nadać w tym samym momencie, co nazywa się inicjalizacją:

#include <stdio.h>

int main(void) {
    int age = 30;
    double price = 19.99;
    char grade = 'A';

    printf("Wiek: %d\n", age);
    printf("Cena: %.2f\n", price);
    printf("Ocena: %c\n", grade);
    return 0;
}

Zwróć uwagę na specyfikatory formatu: %d dla int, %f dla double, %c dla char. printf nie sprawdza przekazanych wartości: ufa twojemu łańcuchowi formatu, więc niezgodność wypisuje bzdury zamiast zgłosić błąd.

Przypisanie po deklaracji

Gdy zmienna już istnieje, zmieniasz ją za pomocą =:

#include <stdio.h>

int main(void) {
    int score;      /* zadeklarowana, wartość nieznana */

    score = 0;      /* przypisanie */
    printf("Start:   %d\n", score);

    score = 85;     /* ponowne przypisanie: stara wartość znika */
    printf("Srodek:  %d\n", score);

    score = score + 10;   /* odczytaj starą wartość, zapisz nową */
    printf("Koniec:  %d\n", score);
    return 0;
}

W C = to przypisanie, a nie równość. score = score + 10 czyta się jako "weź to, co jest w score, dodaj 10 i wynik z powrotem zapisz w score". Operatorem porównania jest ==, a mylenie ich to tak częsty błąd, że ma osobną sekcję na stronie o wartościach logicznych.

Skrót score += 10 robi to samo mniejszą liczbą znaków; złożone operatory przypisania obejmują całą arytmetykę.

Pułapka niezainicjowanej zmiennej

To najczęstszy błąd początkujących w C i nie powoduje on żadnego błędu kompilacji:

#include <stdio.h>

int main(void) {
    int total;      /* nigdy nie dostała wartości */

    for (int i = 1; i <= 5; i++) {
        total += i; /* odczyt total, zanim ma wartość */
    }

    printf("Total: %d\n", total);
    return 0;
}

Uruchom to. Możesz zobaczyć 15, czyli poprawną odpowiedź. Możesz zobaczyć ogromną losową liczbę. Przy drugim uruchomieniu albo na innej maszynie możesz zobaczyć coś jeszcze innego. Każde z tych zachowań jest "poprawne", bo odczyt niezainicjowanej zmiennej lokalnej to niezdefiniowane zachowanie: standard C nie stawia żadnych wymagań co do tego, co się stanie.

W przeciwieństwie do wielu języków C nie zeruje zmiennych lokalnych. Zmienna lokalna to kawałek stosu, a stos jest pełen pozostałości po wcześniejszych wywołaniach funkcji. Czasem te pozostałości akurat są zerami i właśnie dlatego ten błąd jest tak groźny: często działa podczas testów, a zawodzi na produkcji.

Poprawka to jeden znak:

#include <stdio.h>

int main(void) {
    int total = 0;      /* zainicjowana */

    for (int i = 1; i <= 5; i++) {
        total += i;
    }

    printf("Total: %d\n", total);
    return 0;
}

Wyrób sobie nawyk: inicjalizuj każdą zmienną w miejscu deklaracji. Jeśli naprawdę nie masz jeszcze sensownej wartości, 0 albo NULL to lepsze niż śmieci. I kompiluj z -Wall, które wyłapuje większość przypadków:

warning: 'total' is used uninitialized in this function

Wyjątkiem są zmienne globalne i static: one są automatycznie inicjalizowane zerem. Można na tym polegać, ale napisanie = 0 i tak dokumentuje twoją intencję.

Deklarowanie kilku zmiennych naraz

Zmienne tego samego typu mogą dzielić jedną deklarację, z inicjalizatorami lub bez:

#include <stdio.h>

int main(void) {
    int x = 1, y = 2, z = 3;
    double width = 4.5, height;   /* height jest niezainicjowana */

    height = 2.0;
    printf("%d %d %d\n", x, y, z);
    printf("pole: %.2f\n", width * height);
    return 0;
}

To poprawne i częste przy ściśle powiązanych wartościach, takich jak x, y, z. Tu też kryje się klasyczne nieporozumienie:

int a = 0, b = 0, c = 0;   /* wszystkie trzy to 0 */
int d, e, f = 0;           /* tylko f to 0: d i e to śmieci */

Inicjalizator dotyczy jednej nazwy, a nie całej linii. Gdy wartości mają różne znaczenie, daj każdej osobną linię: lepiej się to czyta i daje czytelniejsze diffy.

Deklarowanie wskaźników w jednej linii ma tę samą pułapkę w ostrzejszej formie:

int *p, q;   /* p to wskaźnik na int; q to zwykły int */

* wiąże się z nazwą, a nie z typem. Deklaruj wskaźniki po jednym w linii.

Zasady i konwencje nazewnictwa

Zasady kompilatora:

• Tylko litery, cyfry i podkreślenia.
• Nazwa nie może zaczynać się od cyfry: total2 jest w porządku, 2total nie.
• Nie może być słowem kluczowym C: żadnej zmiennej o nazwie int, return, for czy double.
• Wielkość liter ma znaczenie: count, Count i COUNT to trzy osobne zmienne.
• Nazwy zaczynające się od podkreślenia albo zawierające podwójne podkreślenie są zarezerwowane dla implementacji. Nie twórz ich.

int itemCount;       /* poprawne */
int item_count;      /* poprawne: typowy styl C */
int _count;          /* poprawne, ale zarezerwowane: unikaj */
int item-count;      /* błąd: '-' to operator odejmowania */
int 3rd_place;       /* błąd: zaczyna się od cyfry */
int float;           /* błąd: słowo kluczowe */

Konwencje, których trzyma się większość kodu w C: snake_case dla zmiennych i funkcji, WIELKIE_LITERY dla stałych makr oraz nazwy mówiące, co oznacza wartość, a nie jakiego jest typu. elapsed_ms jest lepsze niż t; customer_count jest lepsze niż n2.

Krótkie nazwy wciąż są w porządku, gdy zasięg jest malutki: i jako licznik pętli rozumie każdy i nikt nie chce pisać for (int indeks_iteracji_petli = 0; ...).

Gdzie żyje zmienna

Miejsce deklaracji zmiennej decyduje o tym, kto ją widzi i jak długo istnieje. To zasięg, a w skrócie wygląda to tak:

#include <stdio.h>

int shared = 100;       /* globalna: widoczna dla każdej funkcji w tym pliku */

void show(void) {
    printf("show widzi shared = %d\n", shared);
}

int main(void) {
    int local = 5;      /* lokalna w main */

    {
        int inner = 7;  /* lokalna tylko w tym bloku */
        printf("inner = %d, local = %d\n", inner, local);
    }
    /* tutaj inner już nie istnieje */

    show();
    printf("main widzi local = %d\n", local);
    return 0;
}

Zmienna jest widoczna od swojej deklaracji do nawiasu zamykającego blok, w którym się znajduje. Zmienne globalne żyją przez cały czas działania programu i są widoczne wszędzie, co brzmi wygodnie i właśnie dlatego sprawiają kłopoty: każda funkcja może je zmienić, więc ustalenie, która to zrobiła, zamienia się w przeszukiwanie całego pliku. Wybieraj zmienne lokalne i przekazuj wartości do funkcji jako parametry.

Deklarowanie w dowolnym miejscu (C99 i nowsze)

W pierwotnym C89 każda deklaracja musiała stać przed jakąkolwiek instrukcją w bloku:

int main(void) {
    int i, sum = 0;      /* najpierw wszystkie deklaracje */
    printf("Start\n");
    for (i = 0; i < 10; i++) { sum += i; }
    return 0;
}

Od C99 możesz deklarować tam, gdzie wartość jest potrzebna po raz pierwszy, także w nagłówku for:

#include <stdio.h>

int main(void) {
    printf("Start\n");

    int sum = 0;                          /* zadeklarowana tam, gdzie jest potrzebna */
    for (int i = 0; i < 10; i++) {        /* zasięg i ogranicza się do pętli */
        sum += i;
    }

    printf("Suma: %d\n", sum);
    return 0;
}

To lepszy styl: deklaracja stoi obok pierwszego użycia, a i nie może wyciec do reszty funkcji. Skompiluj z -std=c17 (albo dowolnym ustawieniem C99+) i zadziała wszędzie.