C++-Variablen: Deklaration, Initialisierung und Gültigkeitsbereich erklärt

Was eine Variable ist

Eine Variable ist ein benannter Speicherbereich, der einen Wert enthält. In C++ hat jede Variable einen festen Typ - festgelegt bei der Deklaration -, und dieser Typ ändert sich nie. Das macht C++ statisch typisiert: Der Compiler kennt den Typ jeder Variable, bevor das Programm läuft, und weigert sich, Code zu kompilieren, der einen Wert der falschen Art speichert.

Eine Deklaration besteht aus drei Teilen: dem Typ, dem Namen und (fast immer) einem Anfangswert.

#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;
}

Lies int age = 30; als „erstelle einen int namens age und lege 30 hinein". Das Semikolon beendet die Anweisung, genau wie die Seite zu Kommentaren für jede Anweisung gezeigt hat. Beachte, dass isActive als 1 ausgegeben wurde: Ein bool wird standardmäßig als 1/0 angezeigt - darauf baut die Seite zu den Datentypen auf.

Initialisierung vs. Zuweisung

Diese beiden sehen ähnlich aus, sind aber unterschiedliche Operationen, und dieser Unterschied ist eine der wichtigsten Ideen auf dieser Seite.

Die Initialisierung gibt einer Variable als Teil der Deklaration ihren ersten Wert. Die Zuweisung ändert den Wert einer bereits existierenden Variable.

#include <iostream>
using namespace std;

int main() {
    int score = 95;   // Initialisierung - erster Wert, bei der Deklaration vergeben
    score = 100;      // Zuweisung - Ändern einer existierenden Variable
    score = score + 5;

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

Du kannst ohne Initialisierung deklarieren und später zuweisen, aber sei vorsichtig:

#include <iostream>
using namespace std;

int main() {
    int score;     // deklariert, enthält aber gerade Müll
    score = 95;    // jetzt hat sie einen echten Wert
    cout << score << "\n";
    return 0;
}

Das funktioniert, weil wir score zugewiesen haben, bevor wir es gelesen haben. Die gefährliche Variante ist, es zuerst zu lesen - das kommt als Nächstes.

Die Falle der nicht initialisierten Variable

Das ist die klassische C++-Falle, die es in vielen anderen Sprachen nicht gibt. Das Lesen einer lokalen Variable, die deklariert wurde, aber nie einen Wert bekommen hat, ist undefiniertes Verhalten: Die Variable enthält die Bytes, die zufällig in diesem Speicher lagen.

int score;             // nicht initialisiert
std::cout << score;    // undefiniertes Verhalten - gibt Müll aus, oder „funktioniert", oder stürzt ab

Der Compiler baut das anstandslos. Es kann 0 ausgeben, es kann 32766 ausgeben, und es kann sich bei jedem Lauf oder auf jeder Maschine anders verhalten - was diese Bugs zur Qual macht, wenn man sie aufspüren will. Zwei Verteidigungen:

• Initialisiere immer bei der Deklaration. int score = 0; kostet nichts und beseitigt das gesamte Problem.
• Schalte Warnungen ein. Das Kompilieren mit -Wall -Wextra lässt den Compiler viele nicht initialisierte Lesezugriffe melden, bevor sie dir schaden.

Bevorzuge für jede lokale Variable die erste Option: gib ihr einen sinnvollen Startwert in dem Moment, in dem du sie erstellst.

Initialisierungsstile: =, () und {}

C++ bietet dir mehrere Möglichkeiten, einen Anfangswert zu schreiben. Meist tun sie dasselbe, aber die Klammer-Initialisierung hat ein zusätzliches Sicherheitsmerkmal, das man kennen sollte.

#include <iostream>
using namespace std;

int main() {
    int a = 5;     // Kopier-Initialisierung
    int b(5);      // direkte Initialisierung
    int c{5};      // Klammer-Initialisierung (einheitlich) - C++11 und neuer

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

Der Grund, zu {} zu greifen, ist, dass es verengende Umwandlungen (narrowing) ablehnt - Zuweisungen, die stillschweigend Daten verlieren würden. Mit = wird ein gebrochener Wert lautlos abgeschnitten; mit {} stoppt dich der Compiler:

int x = 3.9;    // kompiliert - x wird stillschweigend 3 (die .9 wird verworfen)
int y{3.9};     // Kompilierfehler - die Verengung von double zu int ist nicht erlaubt

Das zur Kompilierzeit abzufangen ist genau das, was du willst. Eine gängige moderne Gewohnheit ist, für diese zusätzliche Prüfung standardmäßig {} zu verwenden und nur dann auf = zurückzugreifen, wenn sich die Kopier-Initialisierung natürlicher liest.

Namensregeln und Konventionen

C++ erzwingt ein paar harte Regeln, und alle setzen dann Konventionen darauf. Die Regeln: Ein Name darf Buchstaben, Ziffern und _ enthalten; er darf nicht mit einer Ziffer beginnen; er darf kein reserviertes Schlüsselwort sein (wie int oder return); und er unterscheidet Groß- und Kleinschreibung (age und Age sind zwei verschiedene Variablen). Vermeide Namen, die mit einem Unterstrich gefolgt von einem Großbuchstaben beginnen oder die zwei Unterstriche hintereinander enthalten - diese sind für die Implementierung reserviert.

Die Konventionen, denen der meiste C++-Code folgt:

• Variablen verwenden snake_case oder camelCase - wähle eines und bleib konsistent: item_count oder itemCount.
• Namen sollten den Wert beschreiben: count, nicht c; user_email, nicht 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;
}

Klare Namen sind keine Verzierung - sie sind die Art, wie dein zukünftiges Ich den Code liest. total_price = item_count * price_per_item erklärt sich auf eine Weise von selbst, die t = c * p niemals erreichen wird.

Gültigkeitsbereich von Variablen

Eine Variable existiert nur innerhalb des Blocks - der { ... } -, in dem sie deklariert wird, und sie wird bei der schließenden Klammer zerstört. Das ist ihr Gültigkeitsbereich (scope). Eine in einer Schleife oder einem if-Block deklarierte Variable ist außerhalb davon unsichtbar:

#include <iostream>
using namespace std;

int main() {
    int total = 0;

    for (int i = 1; i <= 3; i++) {
        int square = i * i;   // 'square' lebt nur innerhalb dieses Schleifenkörpers
        total += square;
    }

    cout << "Total: " << total << "\n";
    // cout << square;   // Fehler - 'square' ist hier außerhalb des Gültigkeitsbereichs
    return 0;
}

Sowohl i als auch square gehören zur Schleife und verschwinden, wenn sie endet; total ist im äußeren Block deklariert, also überlebt es. Ein innerer Block kann einen Namen aus einem äußeren Block auch verdecken (shadow): Eine neue Variable mit demselben Namen verbirgt die äußere vorübergehend, bis der innere Block schließt - eine häufige Quelle der Verwirrung. Vermeide es daher, Namen über verschachtelte Gültigkeitsbereiche hinweg wiederzuverwenden.

Die praktische Erkenntnis: Deklariere jede Variable im kleinsten Block, der sie braucht, und initialisiere sie dort. Ein enger Gültigkeitsbereich bedeutet weniger Namen, die um deine Aufmerksamkeit konkurrieren, und weniger Gelegenheiten, einen Wert weit entfernt von der Stelle zu lesen, an der er gesetzt wurde.

Als Nächstes: Datentypen

Jede Variable auf dieser Seite begann mit einem Typ - int, double, string, bool. Die nächste Seite schlüsselt die Datentypen von C++ im Detail auf: die fundamentalen Typen und ihre Größen, vorzeichenbehaftete vs. vorzeichenlose Ganzzahlen, float vs. double, char und wie man den richtigen Typ für die Aufgabe wählt.