Pointere og dynamisk hukommelse

Computerspace · FGU · Programmering i C++

🔐 Hvad er pointere og dynamisk hukommelse?

Pointere er en af C++'s mest kraftfulde og udfordrende features. En pointer gemmer adressen på et andet objekt i hukommelsen.

Grundlæggende pointer-syntax:

```cpp

int alder = 19;

int* ptr = &alder; // ptr peger på adressen til alder

std::cout << alder; // 19 (selve værdien)

std::cout << &alder; // 0x7fff... (adressen)

std::cout << ptr; // 0x7fff... (adressen ptr gemmer)

std::cout << *ptr; // 19 (dereferencing: værdien på adressen)

*ptr = 25; // Ændr værdien via pointeren

std::cout << alder; // 25

```

Stack vs. Heap:

```cpp

// Stack – automatisk styret

int x = 10; // Oprettes og slettes automatisk

// Heap – manuel styring

int* p = new int(42); // Allokér hukommelse på heap

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

delete p; // VIGTIGT: Frigiv hukommelsen!

p = nullptr; // Sæt til nullptr efter delete

```

Memory leaks:

```cpp

// BAD: Memory leak – glemmer delete

void badFunction() {

int* p = new int(10);

// Glemmer: delete p;

} // p slettes, men hukommelsen på heap ikke!

// GOOD: Husk altid delete

void goodFunction() {

int* p = new int(10);

// ... brug p ...

delete p;

}

```

Smart pointers – moderne løsning (C++11):

```cpp

#include <memory>

// unique_ptr – ét ejerskab

std::unique_ptr<int> p = std::make_unique<int>(42);

// Sletter automatisk når p går ud af scope!

// shared_ptr – delt ejerskab

std::shared_ptr<int> sp = std::make_shared<int>(100);

```

---

🎓 Læringsmål for Pointere og dynamisk hukommelse

Læringsmål

• Forstå hvad en pointer er og bruge & og * operatorerne korrekt
• Kende forskellen på stack og heap hukommelse
• Allokere og frigive dynamisk hukommelse med new og delete
• Forstå hvad memory leaks er og hvordan man undgår dem
• Bruge smart pointers (unique_ptr og shared_ptr) som moderne alternativ

Sådan kan du arbejde med emnet

• Hvad er en pointer?
• Hvad er forskellen på stack og heap?
• Hvad er et memory leak?
• Hvad er en smart pointer og hvorfor er det bedre end raw pointers?

⚠️ Typiske fejl at undgå

• Dangling pointer – brug af pointer efter delete – sæt altid til nullptr bagefter
• Glemmer delete – hver new skal have et tilsvarende delete
• Double free – kald aldrig delete to gange på samme pointer
• Null pointer dereference – tjek altid om pointer er nullptr før brug

---

💡 Tips til at komme i gang

• Brug smart pointers i nyt kode – unique_ptr og shared_ptr er sikrere end raw pointers
• Tegn hukommelsesmodellen – visualisér stack og heap for at forstå hvad der sker
• Brug Valgrind (Linux/Mac) til at opdage memory leaks i dine programmer