Assignment Chef icon Assignment Chef
All German tutorials

Programming lesson

Zeiger in C++ meistern: Drei praxisnahe Übungen für Studierende (2026)

Lerne, wie du in C++ mit Zeigern arbeitest – von der Umwandlung von Referenzen bis zu dynamischen Arrays. Drei Aufgaben mit Schritt-für-Schritt-Erklärungen, perfekt für dein Assignment #10.

C++ Zeiger Zeiger Übungen Informatik 1081 Assignment 10 C++ Pointer Tutorial dynamische Arrays C++ Referenzen in Zeiger umwandeln Array umkehren C++ Array erweitern C++ Speicherverwaltung C++ C++ Programmierung Studium 2026 C++ Trends KI Programmierung C++ Spieleentwicklung C++ Zeiger Finanzanalyse C++ C++ Aufgaben mit Lösungen Pointer vs Reference C++

Einleitung: Warum Zeiger in C++ auch 2026 unverzichtbar sind

In der Informatik 1081 dreht sich in Assignment #10 alles um Zeiger und dynamische Speicherverwaltung. Zeiger sind das Herzstück von C++ und ermöglichen eine effiziente Speicherverwaltung – eine Fähigkeit, die selbst in modernen KI-Anwendungen und Spieleentwicklung essenziell ist. Stell dir vor, du entwickelst eine Echtzeit-Strategiespiel-Engine: Jede Einheit wird dynamisch allokiert, und Zeiger verwalten die Verkettung von Aktionen. Oder in einer Finanz-App, die Aktienkurse analysiert – Zeiger helfen, große Datenmengen ohne Kopie zu bearbeiten. Dieser Leitfaden führt dich durch drei typische Aufgaben, wie sie in vielen C++-Kursen vorkommen. Wir nutzen den aktuellen Trend Juni 2026, um die Beispiele frisch zu halten: Denk an ein Turnier-Bracket für die E-Sports-WM 2026 oder an eine KI-gestützte Playlist, die sich dynamisch anpasst.

Programm 1: Von Referenzen zu Zeigern – Der erste Schritt

Die Ausgangslage

Gegeben ist eine Funktion, die zwei int-Referenzen nimmt und Werte vertauscht sowie modifiziert. Deine Aufgabe: Schreibe sie mit Zeigern um. Das ist wie ein Meme-Remix – du behältst die Essenz, änderst aber die Syntax. In der Praxis nutzt man Zeiger oft, um dynamische Datenstrukturen wie verkettete Listen zu verwalten.

Lösungsansatz

Referenzen sind Aliasnamen; Zeiger speichern Adressen. Die Funktion doSomething(int *x, int *y) bekommt jetzt Adressen. Der Aufruf erfolgt mit &x und &y. Innerhalb dereferenzierst du mit *x. So wird aus x = y * 10 ein *x = *y * 10. Das klingt simpel, aber viele Anfänger stolpern über die Dereferenzierung. Ein Tipp: Stell dir vor, x ist ein GPS-Koordinaten-Zeiger auf den Speicherort eines Spieler-Scores in deinem E-Sports-Turnier. Du änderst den Wert an dieser Koordinate.

int doSomething(int *x, int *y) {
    int temp = *x;
    *x = *y * 10;
    *y = temp * 10;
    return *x + *y;
}

Im main fragst du nach zwei Integer-Werten und rufst die Funktion auf. Die Ausgabe zeigt den Rückgabewert und die geänderten Originalwerte – genau wie im Assignment-Beispiel. Das stärkt dein Verständnis für Call-by-Reference vs. Call-by-Value.

Häufige Fehler und wie du sie vermeidest

  • Vergessen der Dereferenzierung: x = y * 10 ändert die Adresse, nicht den Wert. Immer *x schreiben.
  • Falscher Aufruf: doSomething(x, y) statt doSomething(&x, &y). Der Compiler meckert dann.
  • Rückgabetyp: Die Funktion gibt int zurück, nicht int*.

Diese Umstellung ist wie das Upgrade von einem Star-Wars-Legosatz auf die erwachsene Version – gleiche Idee, mehr Kontrolle.

Programm 2: Array-Umkehrung mit Zeigern – Wie ein Playlist-Rewind

Das Ziel

Schreibe eine Funktion, die ein Array und seine Größe als Argumente nimmt, ein neues Array mit umgekehrter Reihenfolge erstellt und einen Zeiger darauf zurückgibt. Stell dir vor, du hast eine KI-generierte Playlist für den Sommer 2026 – und willst sie rückwärts abspielen. Oder du arbeitest an einem Bildverarbeitungsprogramm, das Pixel-Arrays spiegelt.

Schritt-für-Schritt-Umsetzung

  1. Dynamische Allokation: int *reversed = new int[size]; – das erzeugt Speicher auf dem Heap. Vergiss nicht, später delete[] aufzurufen, sonst gibt es ein Memory Leak.
  2. Füllen in umgekehrter Reihenfolge: Mit einer Schleife von i = 0 bis size-1 setzt du reversed[i] = original[size - 1 - i].
  3. Rückgabe: return reversed; – der Zeiger auf das erste Element.
int* reverseArray(int* arr, int size) {
    int* reversed = new int[size];
    for (int i = 0; i < size; i++) {
        reversed[i] = arr[size - 1 - i];
    }
    return reversed;
}

Im main erstellst du das Original-Array dynamisch, lässt den Benutzer Werte eingeben und rufst die Funktion auf. Dann gibst du beide Arrays aus. Denk dran: Das Original bleibt unverändert – wie ein Backup deiner Social-Media-Posts, bevor du sie bearbeitest.

Warum dynamische Arrays?

In modernen C++-Projekten wie Spiele-Engines oder Finanzanalyse-Tools ist die Größe von Daten oft erst zur Laufzeit bekannt. Dynamische Arrays mit new sind die Grundlage für Vektoren und Listen. Wer das beherrscht, versteht auch Smart Pointer – ein heißes Thema in C++-Interviews 2026.

Programm 3: Array-Expansion mit Nullen – Wie ein KI-Modell, das Platz für neue Daten schafft

Die Aufgabenstellung

Schreibe eine Funktion, die ein Array und seine Größe nimmt, ein neues Array doppelter Größe erstellt, die alten Werte kopiert und die neuen Elemente mit Null initialisiert. Das erinnert an maschinelles Lernen, wo du einen Feature-Vektor erweiterst, um Platz für neue Merkmale zu schaffen. Oder in der Spieleentwicklung: Du hast eine Liste von Gegnern und möchtest Platz für weitere reservieren.

Implementierung

  1. Neues Array: int *expanded = new int[2 * size];
  2. Kopieren: Schleife von 0 bis size-1 kopiert expanded[i] = original[i].
  3. Null-Initialisierung: Die restlichen Elemente sind automatisch Null, da new für int keine Garantie gibt – aber du initialisierst sie explizit per Schleife oder mit memset. In der Praxis nutzt man besser std::vector, aber hier geht es um das Verständnis von Zeigern.
int* expandArray(int* arr, int size) {
    int* expanded = new int[2 * size](); // () initialisiert mit 0
    for (int i = 0; i < size; i++) {
        expanded[i] = arr[i];
    }
    return expanded;
}

Beachte: new int[2*size]() setzt alle Werte auf Null. Das ist effizient und lesbar. Im main erstellst du wieder das Original-Array, füllst es und rufst die Funktion auf. Die Ausgabe zeigt das erweiterte Array mit Nullen am Ende – wie eine Einkaufsliste, die du um leere Zeilen ergänzt für spätere Einträge.

Speicherfreigabe nicht vergessen!

Jedes new braucht ein delete[]. In größeren Projekten wie einer KI-App kann ein Memory Leak zum Absturz führen. Verwende daher in der Praxis std::unique_ptr oder std::vector. Aber für dieses Assignment zählt der manuelle Umgang.

Trends 2026: Wo Zeiger im echten Leben stecken

Zeiger sind nicht nur akademisch. In der Spieleentwicklung mit Unreal Engine 5 (die auch 2026 aktuell ist) verwaltest du GameObjects über Zeiger. In KI-Frameworks wie TensorFlow werden Tensordaten über Zeiger manipuliert. Selbst in WebAssembly, das immer mehr in Browser-Apps Einzug hält, arbeitest du mit linearem Speicher und Zeigern. Und denk an Smart-Home-Geräte: Die Firmware in deinem IoT-Thermostat nutzt Zeiger, um Sensordaten effizient zu verarbeiten. Kurz: Zeiger sind überall.

Häufige Fallstricke und Tipps für dein Assignment

  • Zeiger und Arrays: Ein Array-Name ist ein konstanter Zeiger auf das erste Element. arr[i] ist identisch zu *(arr + i).
  • Speicherverwaltung: Jedes new erfordert ein delete. Nutze Valgrind oder den Visual Studio Debugger, um Lecks zu finden.
  • Korrekter Funktionsprototyp: Schreibe int* function(int*, int) – der Stern gehört zum Typ.
  • Teste mit Randfällen: Leeres Array (Größe 0) oder negative Größe? Dein Code sollte robust sein.

Fazit: Zeiger sind dein Freund

Mit diesen drei Übungen hast du die Grundlagen der Zeigerprogrammierung in C++ gefestigt. Du kannst Referenzen in Zeiger umwandeln, dynamische Arrays erstellen und manipulieren. Das ist die Basis für fortgeschrittene Themen wie Datenstrukturen und Algorithmen. In der Informatik 1081 wirst du damit glänzen. Und wenn du später an E-Sports-Turnieren, KI-Projekten oder Finanz-Apps arbeitest, wirst du dich an diese Lektion erinnern. Also: Ran an den Code, und denk dran – Übung macht den Meister.