Summary  
This chapter explains how to define a singly linked list node in C, showing how to use pointers to link nodes dynamically and prevent self-referential memory allocation errors.

General domain of usage  
Data structures

En **linked list** i C er en simpel dynamisk datastruktur, der består af elementer kaldet noder.
Hver node indeholder data (såsom en variabel eller et objekt) samt en pointer til den næste node i listen.


Her er et eksempel på, hvordan en typisk node i en enkeltbundet linked list ser ud i C:

c3RydWN0IE5vZGUgewogICAgaW50IGRhdGE7ICAgICAgICAgICAvLyBkYXRhIGluIG5vZGUKICAgIHN0cnVjdCBOb2RlKiBuZXh0OyAgLy8gcG9pbnRlciB0byBuZXh0IG5vZGUKfTs=

Hvis du i stedet for en pointer til den næste node forsøger blot at oprette en instans af en ny node, vil du få en fejl.

Kompileren vil ikke kunne allokere hukommelse til en sådan struktur, da den indeholder sig selv. Det svarer til at forsøge at se på sig selv udefra med sine egne øjne.

Brugen af en pointer løser dette problem, fordi kompileren ved, hvor meget hukommelse der skal allokeres til en pointervariabel.

Pegeren til den sidste node vil altid være `NULL`.

Bemærk

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

struct Node {
    int data;
    struct Node* next;
};

struct Node* createNode(int value);

// Helper: free a list
void freeList(struct Node* head) {
    struct Node* current = head;
    while (current != nullptr) {
        struct Node* tmp = current;
        current = current->next;
        free(tmp);
    }
}

TEST_CASE("createNode returns non-null and correct data") {
    struct Node* node = createNode(42);
    REQUIRE(node != nullptr);
    REQUIRE(node->data == 42);
    REQUIRE(node->next == nullptr);
    free(node);
}

TEST_CASE("createNode multiple nodes and link manually") {
    struct Node* head = createNode(10);
    struct Node* second = createNode(20);
    struct Node* third = createNode(30);

    REQUIRE(head != nullptr);
    REQUIRE(second != nullptr);
    REQUIRE(third != nullptr);

    head->next = second;
    second->next = third;

    REQUIRE(head->data == 10);
    REQUIRE(head->next == second);
    REQUIRE(second->data == 20);
    REQUIRE(second->next == third);
    REQUIRE(third->data == 30);
    REQUIRE(third->next == nullptr);

    freeList(head);
}

TEST_CASE("Single node list") {
    struct Node* node = createNode(100);
    REQUIRE(node != nullptr);
    REQUIRE(node->data == 100);
    REQUIRE(node->next == nullptr);
    free(node);
}

TEST_CASE("Link nodes incrementally") {
    struct Node* head = createNode(1);
    struct Node* second = createNode(2);
    head->next = second;

    struct Node* current = head;
    REQUIRE(current->data == 1);
    current = current->next;
    REQUIRE(current->data == 2);
    REQUIRE(current->next == nullptr);

    freeList(head);
}

TEST_CASE("Create nodes with negative and zero values") {
    struct Node* head = createNode(0);
    struct Node* second = createNode(-10);
    head->next = second;

    REQUIRE(head->data == 0);
    REQUIRE(head->next == second);
    REQUIRE(second->data == -10);
    REQUIRE(second->next == nullptr);

    freeList(head);
}

test.cpp

Få en solid forståelse af, hvordan structs fungerer i C, fra grundlæggende definitioner til avancerede hukommelseskoncepter. Udforsk, hvordan pointers interagerer med strukturerede data, opdag effektive måder at organisere information på, og opbyg selvtillid ved at implementere reelle datastrukturer såsom linked lists.

Udforsk grundlæggende principper for structs, forstå hvorfor de anvendes, og opbyg selvtillid i at definere, oprette og tilgå strukturerede data.

Opdag, hvordan pointere interagerer med structs, lær hvorfor denne forbindelse er vigtig, og behersk nøgleteknikker såsom dynamisk allokering og overførsel af structs til funktioner

Opnå en solid forståelse af, hvordan structs lagres i hukommelsen, udforsk alignment og padding, og lær hvordan unions hjælper med at håndtere delte data effektivt.

Dyk ned i avancerede struct-mønstre, herunder indlejrede og anonyme structs, udforsk praktiske måder at kombinere dem med arrays på, og bliv fortrolig med almindelige datastrukturer.

Opbyg selvtillid ved at implementere en linked list fra bunden, udforsk dens struktur, og opret essentielle funktioner til at tilføje, gennemløbe og håndtere listeelementer.

Grundlæggende Koncept og Struktur

Løsning