C++ Variablen und Datentypen: Experten‑Guide zu int, double, char, string, bool

Variablen in C++

In C++ ist eine Variable ein benannter Speicherbereich, der es dem Programmierer ermöglicht, Daten zu halten und zu manipulieren. Jede Variable hat einen expliziten Typ, der ihren Speicherbedarf, den zulässigen Wertebereich und die möglichen Operationen festlegt.

Dieses Tutorial behandelt:

• Variablen in C++
• Grundlegende Variablentypen
• Deklarationsregeln
• Datentyp‑Hierarchie
• Bezeichner und Namenskonventionen
• const‑Qualifizierer
• Gültigkeitsbereiche (Scope)
• Implizite und explizite Typumwandlung
• register‑Variablen
• Kommentare und Escape‑Sequenzen

Grundlegende Variablentypen in C++

int – Ganze Zahlen ohne Bruch‑ oder Exponentialteil (z. B. 120, ‑90).

double – Gleitkommazahlen mit doppelter Genauigkeit (z. B. 11.22, 2.345).

char – Einzelne Zeichen in einfachen Anführungszeichen (z. B. 'a', 'm', 'F', 'P', '}').

float – Gleitkommazahlen mit einfacher Genauigkeit (z. B. 1.3, 2.6).

string – Zeichenketten in doppelten Anführungszeichen (z. B. "Wie geht es dir?").

bool – Speichert entweder true oder false.

Regeln für die Deklaration von Variablen in C++

• Namen dürfen Buchstaben, Ziffern und Unterstriche enthalten.
• Sie dürfen nicht mit einer Ziffer beginnen.
• Üblicherweise werden Variablen klein geschrieben; Großbuchstaben am Anfang kennzeichnen oft Konstanten.
• Namen dürfen nicht mit Sprachschlüsselwörtern kollidieren (z. B. int).
• Ein führender Unterstrich ist erlaubt, wird aber wegen reservierter Bezeichner nicht empfohlen.

C++ Variablen‑Datentypen

C++ bietet eine reiche Menge an primitiven Typen. Der Typ void hat keinen Wert und wird typischerweise als Rückgabetyp von Funktionen verwendet, die nichts zurückgeben.

Arithmetische Typen gliedern sich in zwei Kategorien:

1. Gleitkommatypen: float (≈32 Bit), double (≈64 Bit) und long double (≈96/128 Bit, implementationsabhängig).
2. Ganzzahltypen: Integer, Zeichen und bool. Ganzzahltypen können vorzeichenbehaftet (signed) oder vorzeichenlos (unsigned) sein.

Vorzeichenbehaftete Typen repräsentieren negative, null und positive Werte. Ein 8‑Bit‑signed char reicht z. B. von –127 bis 127.

Vorzeichenlose Typen speichern nur nicht‑negative Werte. Ein 8‑Bit‑unsigned char reicht von 0 bis 255.

Variablennamen / Bezeichner

Bezeichner dürfen Buchstaben, Ziffern und Unterstriche enthalten. Die Länge ist unbegrenzt, und sie unterscheiden Groß‑/Kleinschreibung:

int guru99, gurU99, GuRu99, GURU99;

Reservierte Schlüsselwörter dürfen nicht als Bezeichner verwendet werden. Klare Namenskonventionen verbessern die Lesbarkeit: Variablen klein schreiben, bei mehrteiligen Namen camelCase oder snake_case nutzen, Klassennamen groß beginnen.

Deklarations‑ und Definitionsbeispiele

int a = 5;
int b;
char c = 'A';
int a, b;
a = b = 1000;
int a(5);
int b{5};

const‑Qualifizierer in C++

Verwenden Sie const, wenn ein Wert nach der Initialisierung unveränderlich bleiben soll:

const int bufSize = 512; // Eingabepuffer‑Größe

Eine const‑Variable muss initialisiert werden; andernfalls meldet der Compiler einen Fehler.

const int i = get_size(); // OK: Initialisierung zur Laufzeit
const int j = 42;         // OK: Initialisierung zur Compile‑Zeit
const int k;              // Fehler: uninitialisiertes const
const int i = 42;
const int ci = i;         // OK: Kopie von i

Gültigkeitsbereich (Scope) von Variablen in C++

Der Gültigkeitsbereich definiert, wo ein Name sichtbar ist. Variablen sind von ihrer Deklaration bis zum Ende des umgebenden Blocks zugänglich.

#include <iostream>
int main() {
    int sum = 0;
    for (int val = 1; val <= 10; ++val)
        sum += val;
    std::cout << "Summe von 1 bis 10 ist " << sum << std::endl;
    return 0;
}

• main hat globalen Gültigkeitsbereich.
• sum hat Block‑Gültigkeitsbereich innerhalb von main.
• val hat lokalen Gültigkeitsbereich innerhalb der for‑Schleife.

Verschachtelter Gültigkeitsbereich

#include <iostream>
using namespace std;
int reused = 42; // globaler Gültigkeitsbereich
int main() {
    int unique = 0; // Block‑Gültigkeitsbereich
    cout << reused << " " << unique << endl; // 42 0
    int reused = 0; // lokale Variable verdeckt globale
    cout << reused << " " << unique << endl; // 0 0
    cout << ::reused << " " << unique << endl; // 42 0
    return 0;
}

Variablen‑Typumwandlung

C++ führt unter bestimmten Bedingungen implizite Konvertierungen durch. Wichtige Regeln:

• Nicht‑bool zu bool: 0 wird zu false; jeder andere Wert zu true.

  bool b = 42; // b ist true

• bool zu arithmetisch: true wird zu 1, false zu 0.

  bool b = true; int i = b; // i ist 1

• Gleitkomma zu Integer: Abschneiden Richtung null.

  int i = 3.14; // i ist 3

• Integer zu Gleitkomma: Bruchteil geht verloren.

  int i = 3; double pi = i; // pi ist 3.0

• Unsigned‑Überlauf: Wert läuft modulo Basis über.

  unsigned char c = -1; // 255 bei 8‑Bit‑char

• Signed‑Überlauf: undefiniertes Verhalten.

Beim Mischen von vorzeichenbehafteten und vorzeichenlosen Integern können negative Werte unerwartet in große vorzeichenlose Werte umgewandelt werden.

register‑Variablen

Mit dem Schlüsselwort register schlagen Sie dem Compiler vor, eine häufig genutzte Variable in einem CPU‑Register zu halten. Moderne Compiler ignorieren diesen Hinweis meist und optimieren selbst.

register int i;

Kommentare

Kommentare werden vom Compiler ignoriert und dienen der Dokumentation:

• Einzeilig – beginnen mit //.
• Mehrzeilig – werden von /* ... */ umschlossen.

/* Dies ist ein Kommentar */
/* C++‑Kommentare können auch
   mehrere Zeilen umfassen */

Escape‑Sequenzen

Escape‑Sequenzen stellen nicht‑druckbare oder spezielle Zeichen dar:

Escape	Beschreibung
\n	Zeilenumbruch (Newline)
\t	Horizontales Tabulatorzeichen
\\	Backslash
\b	Backspace
\r	Wagenrücklauf (Carriage return)
\v	Vertikales Tabulatorzeichen
\f	Seitenvorschub (Formfeed)
\a	Signalton (Bell)
\"	Doppeltes Anführungszeichen
\'	Einfaches Anführungszeichen
\?	Fragezeichen

cout << '\n';          // Zeilenumbruch
cout << "\tguru99!\n"; // Tab + Text + Zeilenumbruch

Generalisierte Sequenzen nutzen hexadezimale oder oktale Werte:

\7   // Bell
\12  // Newline
\40  // Leerzeichen
\x4D // 'M'

Zusammenfassung

• Variablen bieten benannten Speicher und sind typisiert.
• Primäre Typen: int, double, char, float, string, bool.
• Scope definiert Sichtbarkeit; verschachtelte Scopes können Namen verdecken.
• Implizite und explizite Konvertierungen existieren, müssen aber vorsichtig eingesetzt werden.
• register‑Hinweise können die Performance verbessern, sind aber nur Empfehlungen.
• Kommentare und Escape‑Sequenzen erhöhen Lesbarkeit und korrekte Ausgabe.