C++ Grundlagen

6 Kernkonzepte

Die wichtigsten Grundlagen der C++-Programmierung: Syntax · Datentypen · Kontrollstrukturen · Funktionen · Referenzen · const C++ ist eine mächtige, systemnahe Programmiersprache. Diese Grundlagen sind essenziell für die Entwicklung performanter Anwendungen, Spiele und eingebetteter Systeme.

Syntax – Grundlegende Struktur

#include · main() · std::cout

#include <iostream> int main() { std::cout << "Hallo Welt!" << std::endl; return 0; }

C++-Programme bestehen aus Funktionen, wobei main() der Einstiegspunkt ist. Jede Anweisung endet mit einem Semikolon (;). Die iostream-Bibliothek ermöglicht Ein- und Ausgabe.

Wichtige Syntax-Elemente

Element	Beschreibung
#include	Header-Datei einbinden
int main()	Hauptfunktion (Einstiegspunkt)
std::cout	Ausgabe auf die Konsole
std::cin	Eingabe von der Konsole
std::endl	Zeilenumbruch + Puffer leeren
// Kommentar	Einzeiliger Kommentar
/* */	Mehrzeiliger Kommentar

Beispiele

#include <iostream>

#include <string>

int main() {

// Variablen deklarieren und initialisieren

std::string name = "Anna";

int alter = 30;

// Ausgabe mit std::cout

std::cout << "Name: " << name << std::endl;

// Eingabe mit std::cin

std::cout << "Ihr Alter: ";

std::cin >> alter;

std::cout << "Alter: " << alter << std::endl;

return 0;

}

Tipp: Mit using namespace std; können Sie std:: weglassen – aber das wird in größeren Projekten oft vermieden, um Namenskonflikte zu verhindern.

Datentypen – int, double, char, bool, string

int · double · char · bool · std::string

int zahl = 42; // Ganzzahl double pi = 3.14159; // Gleitkommazahl char buchstabe = 'A'; // Zeichen bool istWahr = true; // Wahrheitswert std::string name = "Anna"; // Text

Datentypen definieren, welche Art von Daten eine Variable speichern kann. C++ bietet sowohl primitive Typen als auch komplexe Typen wie std::string aus der Standardbibliothek.

Die wichtigsten Datentypen

Typ	Größe	Bereich	Beispiel
int	4 Byte	-2.147.483.648 bis 2.147.483.647	42
double	8 Byte	±1.7e−308 bis ±1.7e+308	3.14159
float	4 Byte	±3.4e−38 bis ±3.4e+38	3.14f
char	1 Byte	ASCII-Zeichen	'A'
bool	1 Byte	true / false	true
std::string	variabel	Text	"Hallo"
unsigned int	4 Byte	0 bis 4.294.967.295	100u

Beispiele

// Ganzzahlen

int a = 42;

unsigned int b = 100;

// Gleitkommazahlen

double c = 3.14159;

float d = 2.718f;

// Zeichen und Texte

char e = 'X';

std::string f = "Hallo Welt";

// Wahrheitswert

bool g = true;

// Typumwandlung (casting)

int zahl = 42;

double gleit = static_cast<double>(zahl);

Tipp: Verwenden Sie auto für die automatische Typableitung, wenn der Typ offensichtlich ist: auto x = 42; (int) oder auto y = 3.14; (double).

Kontrollstrukturen – if, for, while, switch

if · else · for · while · switch

if (x > 0) { std::cout << "Positiv"; } else if (x < 0) { std::cout << "Negativ"; } else { std::cout << "Null"; }

Kontrollstrukturen steuern den Programmablauf – sie entscheiden, welche Codeblöcke unter welchen Bedingungen ausgeführt werden und wie oft Schleifen durchlaufen werden.

Die wichtigsten Kontrollstrukturen

Struktur	Beschreibung	Beispiel
if / else	Bedingte Ausführung	if (x > 0) { ... }
for	Zählergesteuerte Schleife	for (int i = 0; i < 10; i++) { ... }
while	Kopfgesteuerte Schleife	while (x < 10) { ... }
do-while	Fußgesteuerte Schleife	do { ... } while (x < 10);
switch	Fallunterscheidung	switch (x) { case 1: ... }
break	Schleife beenden	break;
continue	Schleifendurchlauf überspringen	continue;

Beispiele

// if-else

int score = 85;

if (score >= 90) {

std::cout << "Sehr gut";

} else if (score >= 70) {

std::cout << "Gut";

} else {

std::cout << "Besser lernen";

}

// for-Schleife

for (int i = 0; i < 5; i++) {

std::cout << i << " ";

} // Ausgabe: 0 1 2 3 4

// while-Schleife

int i = 0;

while (i < 5) {

std::cout << i++ << " ";

}

// switch

switch (option) {

case 1: std::cout << "Option 1"; break;

case 2: std::cout << "Option 2"; break;

default: std::cout << "Unbekannt";

}

Tipp: Verwenden Sie break in switch, um ein Durchfallen (fall-through) zu verhindern. Im default-Fall werden alle nicht behandelten Werte abgefangen.

Funktionen – Rückgabetyp · Parameter · Überladung

return · void · Param · Overload

// Funktionsdeklaration int add(int a, int b); // Funktionsdefinition int add(int a, int b) { return a + b; }

Funktionen sind wiederverwendbare Codeblöcke. Sie haben einen Rückgabetyp, einen Namen und Parameter. C++ unterstützt Funktionsüberladung (mehrere Funktionen mit gleichem Namen).

Beispiele

// Funktion ohne Rückgabewert (void)

void printGreeting(std::string name) {

std::cout << "Hallo " << name << std::endl;

}

// Funktion mit Rückgabewert

int multiply(int a, int b) {

return a * b;

}

// Funktionsüberladung

int max(int a, int b) { return a > b ? a : b; }

double max(double a, double b) { return a > b ? a : b; }

// Default-Parameter

void log(std::string msg, int level = 1) {

std::cout << "[Level " << level << "] " << msg << std::endl;

}

// Aufruf

printGreeting("Anna");

int ergebnis = multiply(3, 4); // 12

log("Starten"); // Level 1

log("Fehler", 3); // Level 3

Tipp: Verwenden Sie const-Parameter (const std::string& name), um Kopien zu vermeiden und die Leistung zu verbessern.

Referenzen & Zeiger – & · * · nullptr

int& · int* · &var · *ptr

// Referenz (Alias für Variable) int x = 5; int& ref = x; // ref ist ein Alias für x // Zeiger (Adresse einer Variable) int* ptr = &x; // ptr zeigt auf x int wert = *ptr; // Dereferenzierung (wert = 5)

Referenzen sind Aliase für vorhandene Variablen – sie werden ohne Kopie verwendet. Zeiger speichern Adressen und ermöglichen dynamische Speicherverwaltung.

Beispiele

// Referenz als Funktionsparameter

void swap(int& a, int& b) {

int temp = a;

a = b;

b = temp;

}

// Zeiger für dynamische Speicherverwaltung

int* ptr = new int(42);

std::cout << *ptr; // 42

delete ptr; // Speicher freigeben

// nullptr (moderner Nullzeiger)

int* nullPtr = nullptr;

if (nullPtr == nullptr) {

std::cout << "Zeiger ist null";

}

// Referenz auf const (verhindert Änderungen)

void print(const std::string& text) {

std::cout << text;

}

Tipp: Verwenden Sie Referenzen für Parameter, die nicht kopiert werden sollen (z.B. große Objekte). Verwenden Sie Zeiger für dynamische Speicherverwaltung oder wenn nullptr möglich sein soll.

const – Konstanten und Unveränderlichkeit

const · constexpr · const&

const int PI = 3.14159; const std::string NAME = "Max"; void print(const std::string& text); constexpr int SIZE = 100; // Kompilierzeit-Konstante

const macht Variablen unveränderlich. Es verbessert die Lesbarkeit, verhindert unbeabsichtigte Änderungen und ermöglicht Compiler-Optimierungen.

Beispiele

// const-Variablen

const int MAX_USERS = 1000;

const double PI = 3.14159265359;

// const-Parameter (schützt vor Änderungen)

void display(const std::string& text) {

// text = "neuer Text"; // Fehler: const

std::cout << text;

}

// constexpr (Kompilierzeit)

constexpr int square(int x) { return x * x; }

constexpr int RESULT = square(5); // 25 zur Kompilierzeit

// const-Referenz auf temporäres Objekt

const std::string& name = std::string("Temp"); // erlaubt (Lebensdauer verlängert)

// const mit Zeigern

int x = 10;

const int* ptr1 = &x; // Zeiger auf const int

int* const ptr2 = &x; // const Zeiger auf int

const int* const ptr3 = &x; // const Zeiger auf const int

Tipp: Verwenden Sie const so oft wie möglich – es macht Code sicherer und hilft dem Compiler bei Optimierungen. constexpr ist für Werte, die zur Compile-Zeit bekannt sind.

C++ Grundlagen im Überblick

#include Header einbinden
iostream, string, vector

int main() Programm-Einstieg
return 0; am Ende

std::cout Ausgabe
<< und std::endl

auto Typableitung
Seit C++11

const Unveränderlich
const, constexpr

& Referenz
Alias für Variable

Quick Summary

main()

Programm-Einstieg

int

Datentypen

if

Kontrollstrukturen

void

Funktionen

&

Referenzen

const

Konstanten

int main() { std::cout << "Hallo"; return 0; } · const int MAX = 100;