C++: Variablen, Typen und Ausgabe

Kurz: int main() { int alter = 17; double preis = 19.99; char buchstabe = ‘A’; bool fertig = true; std::string name = “Mia”; auto zahl = 42; // auto: Typ wird erkannt (int) const double PI = 3.14159;

Teil des Kurses C++

Kapitel 2 von 15 im Kurs C++ (Abschnitt „Grundlagen“). Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

#include <iostream>
#include <string>
#include <format>      // C++20
 
int main() {
    int alter = 17;
    double preis = 19.99;
    char buchstabe = 'A';
    bool fertig = true;
    std::string name = "Mia";
    auto zahl = 42;                          // auto: Typ wird erkannt (int)
    const double PI = 3.14159;
 
    std::cout << name << " ist " << alter << ", Preis " << preis << ", " << buchstabe << ", " << fertig << '\n';
    std::cout << std::boolalpha << fertig << ' ' << std::noboolalpha << zahl << ' ' << PI << '\n';
    std::cout << std::format("{} hat {} Punkte ({:.1f}%)\n", name, 42, 87.5);
    std::cout << std::format("|{:>6}|{:<6}|{:^6}|{:06.2f}|\n", "ab", "cd", "ef", 3.14159);
    return 0;
}

Ausgabe:

Mia ist 17, Preis 19.99, A, 1
true 42 3.14159
Mia hat 42 Punkte (87.5%)
|    ab|cd    |  ef  |003.14|

Typen

Typ	Größe	Hinweis
int, long, long long	4 / 4-8 / 8	ganze Zahlen; unsigned für ≥ 0
double, float	8 / 4	Kommazahlen
char	1	ein Zeichen
bool	1	true/false
std::string		Text, wachsend und veränderbar
std::size_t		Größen und Indizes
std::int32_t, std::uint8_t …	genau	<cstdint>

Initialisierung

Die geschweiften Klammern (uniform initialization) verhindern verlustbehaftete Umwandlungen:

#include <iostream>
 
int main() {
    int a = 7;
    int b{7};                 // empfohlen
    double d{3.5};
    int c = 3.9;              // erlaubt (schneidet ab) ...
    // int e{3.9};            // ... Fehler: narrowing conversion
    int leer{};               // 0
    auto x = 5 / 2;           // 2
    auto y = 5 / 2.0;         // 2.5
    std::cout << a << b << d << c << leer << ' ' << x << ' ' << y << '\n';
    std::cout << sizeof(int) << ' ' << sizeof(double) << ' ' << sizeof(long long) << '\n';
    return 0;
}

Ausgabe:

773.530 2 2.5
4 8 8

Eingabe mit cin

std::string name;
int alter;
std::cout << "Name und Alter: ";
std::cin >> name >> alter;
if (!std::cin) { std::cout << "Ungültige Eingabe\n"; }
 
std::getline(std::cin >> std::ws, name);     // ganze Zeile einlesen

std::cin >> x liest bis zum Leerraum; std::getline liest eine ganze Zeile. Prüfe std::cin auf Fehler (if (!std::cin)).

Auch ohne Tastatur kannst du das mit Strings üben:

#include <iostream>
#include <sstream>
#include <string>
 
int main() {
    std::istringstream eingabe("Mia 17 62.5");
    std::string name; int alter; double gewicht;
    if (eingabe >> name >> alter >> gewicht) {
        std::cout << name << ", " << alter << ", " << gewicht << '\n';
    }
    std::ostringstream aus;
    aus << "Summe: " << 3 + 4;
    std::cout << aus.str() << '\n';
    return 0;
}

Ausgabe:

Mia, 17, 62.5
Summe: 7

Referenzen

Eine Referenz (&) ist ein zweiter Name für eine bestehende Variable. Sie kann nicht neu zugewiesen werden und ist nie leer:

#include <iostream>
 
void erhoehe(int& x) { x++; }                  // Referenz: ändert das Original
int quadrat(const int& x) { return x * x; }    // const-Referenz: lesen ohne Kopie
 
int main() {
    int n = 5;
    int& r = n;                                // r ist ein anderer Name für n
    r = 10;
    erhoehe(n);
    std::cout << n << ' ' << quadrat(n) << '\n';
    return 0;
}

Ausgabe:

11 121

Standard für Funktionsparameter: kleine Typen (int, double) als Wert, große Typen (std::string, std::vector) als const&, Ausgabeparameter als &.

Namensräume

#include <iostream>
 
namespace geometrie {
    const double PI = 3.14159;
    double kreisFlaeche(double r) { return PI * r * r; }
}
 
int main() {
    std::cout << geometrie::kreisFlaeche(2) << '\n';
    using geometrie::PI;                       // einzelnes Element sichtbar machen
    std::cout << PI << '\n';
    return 0;
}

Ausgabe:

12.5664
3.14159

Vermeide using namespace std; in Headern und größeren Programmen: Es führt zu Namenskonflikten.

Merke

• std::string, auto, const; Initialisierung mit {} verhindert Datenverlust
• Ausgabe: std::cout, std::format (C++20); Eingabe: std::cin, std::getline
• Referenzen (&) sind Alias-Namen, const& für große Parameter
• Namensräume (namespace) verhindern Namenskonflikte
• Kein using namespace std; in Headern

Übungsaufgabe

Lies (simuliert über istringstream) drei Zahlen ein und gib mit std::format Summe, Mittelwert und Maximum aus.

Quiz zur Selbstkontrolle

Wofür ist auto?

• Der Compiler erkennt den Typ aus dem Anfangswert (richtig)
• Automatisches Speichern
• Automatische Schleife
• Ein Zeigertyp

Was ist eine Referenz?

• Ein zweiter Name für eine bestehende Variable (richtig)
• Eine Kopie
• Ein Zeiger, der NULL sein darf
• Ein Datentyp für Texte

Warum const std::string& als Parameter?

• Kein Kopieren, und die Funktion ändert das Argument nicht (richtig)
• Der String wird verschlüsselt
• Der String wird gelöscht
• Es ist schneller zu tippen

Weiter im Kurs

Zurück: Was ist C++?

Weiter: Bedingungen und Schleifen

Alle Kapitel: C++ im Überblick