#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;
}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;
}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 einlesenstd::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;
}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;
}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;
}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
Aufgabe
Lies (simuliert über istringstream) drei Zahlen ein und gib mit std::format Summe, Mittelwert und Maximum aus.