Summary  
This chapter explains how to allocate and free memory on the heap at runtime using C++’s new/delete and new[]/delete[] operators to manage dynamic memory safely and avoid leaks or dangling pointers.

General domain of usage  
Implementing dynamic data structures (e.g., resizable arrays or linked lists)

Get a clear, visual walkthrough of dynamic memory allocation in C++. This video covers how and why to use the `new` and `delete` operators, the correct way to allocate and release memory for single variables and arrays, and best practices to prevent memory leaks. See practical examples of pointers, dynamic arrays, and memory management strategies to help you write efficient, error-free C++ programs.

-- video metadata (use this info when making a video) -- Cut all examples of code to a minimum. Show only the essential code. Show code no longer than 12 lines. Remove all possible pieces to demonstrate some code feature. You may show not full code that will not start, but still demonstrates some feature theoritacally. If code is longer than 8 lines, move code output  blocks to second column. Avoid using programming language images in the videos.

**Dynamische Speicherzuweisung** beinhaltet die Verwendung der Operatoren `new` und `delete`. Diese Operatoren ermöglichen es, Speicher für Variablen und Arrays **zur Laufzeit** zu reservieren und bieten dadurch mehr Flexibilität als die statische Speicherzuweisung.

* `new`: Operator, der verwendet wird, um Speicher für ein Objekt oder ein Array von Objekten zur Laufzeit dynamisch zu reservieren;

* `delete`: Operator, der verwendet wird, um Speicher freizugeben, der zuvor mit dem Operator `new` reserviert wurde.


Ein Zeiger, der auf dynamisch zugewiesenen Speicher zeigt, wird typischerweise auf dem Stack gespeichert, **aber** der Speicher, auf den er zeigt, wird auf dem Heap reserviert.

Hinweis

Um eine Integer-Variable dynamisch zu erstellen, muss ein Zeiger zusammen mit dem Schlüsselwort `new` verwendet werden.

```
int *dynamicInteger = new int;
```

Um den dynamisch zugewiesenen Speicher freizugeben, wird der Operator delete verwendet:

```
delete dynamicInteger;
```

Machen Sie es sich zur Regel: Wenn Sie new zur Speicherzuweisung verwenden, nutzen Sie immer delete, um den Speicher später wieder freizugeben.

### Dynamisch zugewiesene Arrays

Bei der dynamischen Speicherzuweisung für Arrays wird der Operator `new[]` verwendet. Zum Freigeben des Speichers für dynamisch zugewiesene Arrays wird der Operator `delete[]` eingesetzt.

Das Nichtlöschen von dynamisch zugewiesenem Speicher kann zu Speicherlecks führen, bei denen das Programm Speicher behält, der nicht mehr verwendet wird.

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


void fillRandomGrades(double* grades, int count);
double calculateAverage(double* grades, int count);

TEST_CASE("calculateAverage returns correct average for positive grades", "[calculateAverage]") {
    double grades[] = {80, 90, 70, 60, 99};
    int count = 5;

    double result = calculateAverage(grades, count);
    double expected = (80 + 90 + 70 + 60 + 99) / 5.0;

    REQUIRE(result == Approx(expected));
}

TEST_CASE("calculateAverage returns correct average for identical grades", "[calculateAverage]") {
    double grades[] = {75, 75, 75, 75};
    int count = 4;

    double result = calculateAverage(grades, count);
    double expected = 75;

    REQUIRE(result == Approx(expected));
}

TEST_CASE("calculateAverage handles single grade", "[calculateAverage]") {
    double grades[] = {88};
    int count = 1;

    double result = calculateAverage(grades, count);
    double expected = 88;

    REQUIRE(result == Approx(expected));
}

TEST_CASE("fillRandomGrades generates grades in range 60-100", "[fillRandomGrades]") {
    const int count = 100;
    double grades[count];

    fillRandomGrades(grades, count);

    for (int i = 0; i < count; ++i) {
        REQUIRE(grades[i] >= 60);
        REQUIRE(grades[i] <= 100);
    }
}

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 Speicherzuweisung

Dynamisch zugewiesene Arrays

Lösung