Zmienne w C++: deklaracja, inicjalizacja i zasięg

Czym jest zmienna

Zmienna to nazwany fragment pamięci, który przechowuje wartość. W C++ każda zmienna ma stały typ, wybierany przy deklaracji, i ten typ nigdy się nie zmienia. To właśnie czyni C++ językiem statycznie typowanym: kompilator zna typ każdej zmiennej, zanim program się uruchomi, i odmawia kompilacji kodu, który zapisuje wartość niewłaściwego rodzaju.

Deklaracja składa się z trzech części: typu, nazwy i (prawie zawsze) wartości początkowej.

#include <iostream>
#include <string>
using namespace std;

int main() {
    int age = 30;
    string name = "Ada";
    bool isActive = true;

    cout << name << " is " << age << ", active: " << isActive << "\n";
    return 0;
}

Czytaj int age = 30; jako "utwórz int o nazwie age i wstaw do niego 30". Średnik kończy instrukcję, tak jak każdą instrukcję na stronie o komentarzach. Zauważ, że isActive wypisało się jako 1: bool domyślnie wyświetla się jako 1/0, do czego nawiązuje strona o typach danych.

Inicjalizacja a przypisanie

Te dwie rzeczy wyglądają podobnie, ale to różne operacje, a ta różnica to jedna z najważniejszych idei na tej stronie.

Inicjalizacja nadaje zmiennej pierwszą wartość w ramach deklaracji. Przypisanie zmienia wartość zmiennej, która już istnieje.

#include <iostream>
using namespace std;

int main() {
    int score = 95;   // inicjalizacja: pierwsza wartość, nadana przy deklaracji
    score = 100;      // przypisanie: zmiana istniejącej zmiennej
    score = score + 5;

    cout << score << "\n";
    return 0;
}

Możesz zadeklarować zmienną bez inicjalizacji i przypisać wartość później, ale uważaj:

#include <iostream>
using namespace std;

int main() {
    int score;     // zadeklarowana, ale teraz zawiera śmieci
    score = 95;    // teraz ma prawdziwą wartość
    cout << score << "\n";
    return 0;
}

To działa, bo score dostaje wartość przed odczytem. Niebezpieczna wersja to odczyt jako pierwszy, o czym dalej.

Pułapka niezainicjalizowanej zmiennej

To klasyczna pułapka C++, której w wielu innych językach nie ma. Odczyt zmiennej lokalnej, która została zadeklarowana, ale nigdy nie dostała wartości, to niezdefiniowane zachowanie: zmienna zawiera bajty, które akurat były w tej pamięci.

int score;             // niezainicjalizowana
std::cout << score;    // niezdefiniowane zachowanie: wypisze śmieci, "zadziała" albo się wysypie

Kompilator bez problemu to zbuduje. Może się wypisać 0, może 32766, a przy każdym uruchomieniu lub na każdym komputerze zachowanie może być inne, przez co takie błędy bardzo trudno wytropić. Dwie linie obrony:

• Zawsze inicjalizuj przy deklaracji. int score = 0; nic nie kosztuje i usuwa cały problem.
• Włącz ostrzeżenia. Kompilacja z -Wall -Wextra sprawia, że kompilator zgłasza wiele odczytów niezainicjalizowanych zmiennych, zanim zdążą zaszkodzić.

Dla każdej zmiennej lokalnej wybieraj pierwszą opcję: nadaj jej sensowną wartość początkową w chwili utworzenia.

Style inicjalizacji: =, () i {}

C++ daje kilka sposobów zapisania wartości początkowej. W większości robią to samo, ale inicjalizacja klamrowa ma jedną dodatkową funkcję bezpieczeństwa, którą warto znać.

#include <iostream>
using namespace std;

int main() {
    int a = 5;     // inicjalizacja przez kopię
    int b(5);      // inicjalizacja bezpośrednia
    int c{5};      // inicjalizacja klamrowa (jednolita): od C++11

    cout << a << " " << b << " " << c << "\n";
    return 0;
}

Powód, by sięgać po {}, jest taki, że odrzuca konwersje zawężające, czyli przypisania, które po cichu gubiłyby dane. Przy = wartość ułamkowa zostaje po cichu obcięta, a przy {} kompilator cię zatrzyma:

int x = 3.9;    // kompiluje się: x po cichu staje się 3 (.9 jest odrzucane)
int y{3.9};     // błąd kompilacji: zawężanie z double do int jest niedozwolone

Wyłapanie tego w czasie kompilacji to dokładnie to, czego chcesz. Popularny współczesny nawyk to domyślne używanie {} dla tej dodatkowej kontroli i sięganie po = tylko wtedy, gdy inicjalizacja przez kopię czyta się naturalniej.

Zasady i konwencje nazewnictwa

C++ narzuca kilka twardych reguł, a na nie wszyscy nakładają konwencje. Reguły: nazwa może zawierać litery, cyfry i _, nie może zaczynać się od cyfry, nie może być zarezerwowanym słowem kluczowym (jak int czy return) i rozróżnia wielkość liter (age i Age to dwie różne zmienne). Unikaj nazw zaczynających się od podkreślenia i wielkiej litery oraz nazw z dwoma podkreśleniami z rzędu: są zarezerwowane dla implementacji.

Konwencje, których trzyma się większość kodu w C++:

• Zmienne zapisuje się w snake_case albo camelCase: wybierz jedno i trzymaj się go konsekwentnie, item_count albo itemCount.
• Nazwy powinny opisywać wartość: count, a nie c; user_email, a nie x.

#include <iostream>
using namespace std;

int main() {
    int item_count = 3;
    double price_per_item = 4.50;
    double total_price = item_count * price_per_item;

    cout << "Total: " << total_price << "\n";
    return 0;
}

Czytelne nazwy to nie ozdoba: dzięki nim za kilka miesięcy nadal zrozumiesz ten kod. total_price = item_count * price_per_item tłumaczy się samo, czego t = c * p nigdy nie osiągnie.

Zasięg zmiennej

Zmienna istnieje tylko wewnątrz bloku, czyli { ... }, w którym ją zadeklarowano, i jest niszczona przy klamrze zamykającej. To jej zasięg (scope). Zmienna zadeklarowana wewnątrz pętli lub bloku if jest poza nim niewidoczna:

#include <iostream>
using namespace std;

int main() {
    int total = 0;

    for (int i = 1; i <= 3; i++) {
        int square = i * i;   // 'square' żyje tylko w ciele tej pętli
        total += square;
    }

    cout << "Total: " << total << "\n";
    // cout << square;   // błąd: 'square' jest tu poza zasięgiem
    return 0;
}

Zarówno i, jak i square należą do pętli i znikają, gdy ta się kończy, a total jest zadeklarowane w bloku zewnętrznym, więc przetrwa. Blok wewnętrzny może też przesłonić nazwę z bloku zewnętrznego: nowa zmienna o tej samej nazwie tymczasowo ukrywa zewnętrzną, aż blok wewnętrzny się zamknie. To częste źródło zamieszania, więc unikaj ponownego używania nazw w zagnieżdżonych zasięgach.

Wniosek praktyczny: deklaruj każdą zmienną w najmniejszym bloku, który jej potrzebuje, i tam ją inicjalizuj. Wąski zasięg oznacza mniej nazw walczących o twoją uwagę i mniej okazji do odczytu wartości daleko od miejsca, w którym ją ustawiono.

Dalej: typy danych

Każda zmienna na tej stronie zaczynała się od typu: int, double, string, bool. Następna strona szczegółowo omawia typy danych w C++: typy podstawowe i ich rozmiary, liczby całkowite ze znakiem i bez znaku, float a double, char oraz to, jak dobrać właściwy typ do zadania.