Summary  
This chapter covers the concept of double pointers in C++, showing how a pointer-to-pointer can be used to dynamically allocate, access, and properly deallocate two-dimensional arrays.  

General domain of usage  
Dynamic allocation of multidimensional arrays

Explore the concept of pointer to pointer (double pointer) in C++. Learn how double pointers are used for dynamic memory allocation of two-dimensional arrays. This video walks you through syntax, visualization, and step-by-step code for allocating and deallocating 2D arrays using pointers to pointers, with practical examples and memory management best practices. Ideal for mastering dynamic data structures in C++ programming! 

Ein **Pointer auf einen Pointer**, bezeichnet als Doppelzeiger (`**`).

Dies ist ein Zeiger, **der die Speicheradresse eines anderen Zeigers speichert**. Einfach ausgedrückt ist es eine Variable, deren Wert die Adresse eines anderen Zeigers ist. Dieses Konzept mag zunächst komplex erscheinen, bietet jedoch eine leistungsstarke Möglichkeit für fortgeschrittene dynamische Speicherverwaltung.

I2luY2x1ZGUgPGlvc3RyZWFtPgoKaW50IG1haW4oKQp7CiAgICBpbnQgeCA9IDEwOwogICAgaW50ICpwdHIxID0gJng7CiAgICBpbnQgKipwdHIyID0gJnB0cjE7CgogICAgLy8gQWNjZXNzaW5nIHZhbHVlcyB1c2luZyBkb3VibGUgcG9pbnRlcgogICAgc3RkOjpjb3V0IDw8ICJBZGRyZXNzIHN0b3JlZCBpbiBwdHIyIChhZGRyZXNzIG9mIHB0cjEpOiAiIDw8IHB0cjIgPDwgc3RkOjplbmRsOwogICAgc3RkOjpjb3V0IDw8ICJBZGRyZXNzIHN0b3JlZCBpbiBwdHIxIChhZGRyZXNzIG9mIHgpOiAiIDw8ICpwdHIyIDw8IHN0ZDo6ZW5kbDsKICAgIHN0ZDo6Y291dCA8PCAiVmFsdWUgb2YgeDogIiA8PCAqKnB0cjIgPDwgc3RkOjplbmRsOwp9

- **ptr1**: ist ein Zeiger auf einen Integer (`int*`);
- **ptr2**: ist ein doppelter Zeiger auf einen Integer (`int**`).

### Dynamische Allokation eines zweidimensionalen Arrays

Wenn ein zweidimensionales Array zur Laufzeit dynamisch erstellt werden soll, muss für die Zeilen ein **Zeiger auf einen Zeiger** verwendet werden.

Anschließend wird jede Zeile mit einem dynamischen Array initialisiert (wie im vorherigen Kapitel).


#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
#include <sstream>
#include <iostream>

void createAndPrint2DArray(int rows, int columns);

TEST_CASE("3x5 array prints correctly", "[createAndPrint2DArray]") {
    std::ostringstream oss;
    std::streambuf* oldCout = std::cout.rdbuf(oss.rdbuf());

    createAndPrint2DArray(3, 5);

    std::cout.rdbuf(oldCout);

    std::string output = oss.str();

    std::string expected = R"(0 1 2 3 4 
5 6 7 8 9 
10 11 12 13 14 
)";

    REQUIRE(output == expected);
}

TEST_CASE("2x3 array prints correctly", "[createAndPrint2DArray]") {
    std::ostringstream oss;
    std::streambuf* oldCout = std::cout.rdbuf(oss.rdbuf());

    createAndPrint2DArray(2, 3);

    std::cout.rdbuf(oldCout);

    std::string output = oss.str();

    std::string expected = R"(0 1 2 
3 4 5 
)";

    REQUIRE(output == expected);
}

TEST_CASE("1x4 array prints correctly", "[createAndPrint2DArray]") {
    std::ostringstream oss;
    std::streambuf* oldCout = std::cout.rdbuf(oss.rdbuf());

    createAndPrint2DArray(1, 4);

    std::cout.rdbuf(oldCout);

    std::string output = oss.str();

    std::string expected = R"(0 1 2 3 
)";

    REQUIRE(output == expected);
}

TEST_CASE("1x2 array prints correctly", "[createAndPrint2DArray]") {
    std::ostringstream oss;
    std::streambuf* oldCout = std::cout.rdbuf(oss.rdbuf());

    createAndPrint2DArray(1, 2);

    std::cout.rdbuf(oldCout);

    std::string output = oss.str();

    std::string expected = R"(0 1 
)";

    REQUIRE(output == expected);
}

test.cpp

Entfesseln Sie die Kraft der Speicherverwaltung. Tauchen Sie tief in die Grundlagen der Programmierung mit diesem umfassenden Kurs ein, der für Anfänger und Personen konzipiert ist, die ihr Wissen über Zeiger und Referenzen in C++ vertiefen möchten. Das Beherrschen dieser grundlegenden Konzepte ist entscheidend, um das volle Potenzial Ihrer Programmierfähigkeiten auszuschöpfen.

Erlernen Sie die Grundlagen von Zeigern auf einfache und verständliche Weise. Entdecken Sie die Funktionsweise von Zeigern, deren Syntax sowie praktische Anwendungsbeispiele anhand klarer Beispiele und leicht nachvollziehbarer Erklärungen.

Untersuchung der Manipulation von Zeigern, die Speicheradressen speichern, mittels arithmetischer Operationen. Navigation durch Speicherbereiche, effizienter Zugriff auf Datenstrukturen und Optimierung des Codes hinsichtlich Leistung.

Erkunden Sie das Konzept von Referenzen als Aliasnamen für Variablen und speichereffizienten Datenzugriff. Erfahren Sie, wie Referenzen zu übersichtlicherem Code, verbesserter Lesbarkeit und gesteigerter Leistung beitragen, indem unnötige Datenkopien vermieden werden.

Entdecken Sie die Prinzipien und Techniken der dynamischen Speicherzuweisung und -freigabe während der Programmausführung. Verstehen Sie die Vorteile und Herausforderungen der dynamischen Speicherverwaltung.

Dynamische Allokation von Zeigern auf Zeiger

Syntax

Dynamische Allokation eines zweidimensionalen Arrays

Lösung