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.

**Dynamisk minneallokering** innebærer bruk av operatorene `new` og `delete`. Disse operatorene lar deg allokere minne for variabler og arrayer **under kjøring**, noe som gir større fleksibilitet enn statisk minneallokering.

* `new`: operator som brukes til å dynamisk allokere minne for et objekt eller et array av objekter under kjøring;

* `delete`: operator som brukes til å frigjøre minne som tidligere ble allokert med `new`-operatoren.


En peker som peker til dynamisk allokert minne lagres vanligvis på stakken, **men** minnet den peker til er allokert på heapen.

Merk

For å opprette en heltallsvariabel dynamisk må du bruke en peker sammen med `new`-nøkkelordet.

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

For å frigjøre dynamisk allokert minne, bruker du delete-operatoren:

```
delete dynamicInteger;
```

Gjør det til en regel: Når du bruker new for å allokere minne, bruk alltid delete for å frigjøre det senere.

### Dynamisk allokerte arrayer

Når du allokerer minne for arrayer dynamisk, bruk operatoren `new[]`, og når du frigjør minne for dynamisk allokerte arrayer, bruk operatoren `delete[]`.

Unnlatelse av å slette dynamisk allokert minne kan føre til minnelekkasjer, der programmet beholder minne som ikke lenger er i bruk.

#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

Lås opp kraften i minnehåndtering. Fordyp deg i grunnleggende programmering med dette omfattende kurset, utviklet for nybegynnere og de som ønsker å styrke kunnskapen om pekere og referanser i C++. Å mestre disse essensielle konseptene er avgjørende for å utnytte det fulle potensialet i dine programmeringsferdigheter.

Lær det grunnleggende om pekere på en enkel og oversiktlig måte. Utforsk hvordan pekere fungerer, deres syntaks og praktiske anvendelser gjennom tydelige eksempler og lettfattelige forklaringer.

Utforsk hvordan pekere, som lagrer minneadresser, kan manipuleres ved hjelp av aritmetiske operasjoner. Lær å navigere gjennom minneområder, få effektiv tilgang til datastrukturer og optimalisere kode for ytelse.

Utforsk konseptet referanser som aliaser for variabler og minneeffektiv tilgang til data. Lær hvordan referanser bidrar til renere kode, forbedret lesbarhet og økt ytelse ved å unngå unødvendig duplisering av data.

Utforsk prinsippene og teknikkene bak dynamisk tildeling og frigjøring av minne under programkjøring. Forstå fordelene og utfordringene ved dynamisk minnetildeling.

Dynamisk Allokering

Dynamisk allokerte arrayer

Løsning