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

Una **lista collegata** in C è una semplice struttura dati dinamica composta da elementi chiamati nodi.
Ogni nodo contiene dati (come una variabile o un oggetto) e un puntatore al nodo successivo nella lista.


Ecco come appare un tipico nodo in una lista collegata semplice in C:

c3RydWN0IE5vZGUgewogICAgaW50IGRhdGE7ICAgICAgICAgICAvLyBkYXRhIGluIG5vZGUKICAgIHN0cnVjdCBOb2RlKiBuZXh0OyAgLy8gcG9pbnRlciB0byBuZXh0IG5vZGUKfTs=

Se invece di un puntatore al nodo successivo si tenta semplicemente di creare un'istanza di un nuovo nodo, si otterrà un errore.

Il compilatore non sarà in grado di allocare memoria per una tale struttura, poiché essa contiene sé stessa. È come cercare di guardarsi dall'esterno con i propri occhi.

L'utilizzo di un puntatore risolve questo problema perché il compilatore sa quanta memoria allocare per una variabile puntatore.

Il puntatore dell'ultimo nodo sarà sempre `NULL`.

Nota

#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

Acquisire una solida comprensione del funzionamento delle struct in C, dalle definizioni di base ai concetti avanzati di memoria. Esplorare come i puntatori interagiscono con i dati strutturati, scoprire modi efficienti per organizzare le informazioni e acquisire sicurezza implementando strutture dati reali come le liste collegate.

Esplora i fondamenti delle struct, comprendi perché vengono utilizzate e acquisisci sicurezza nella definizione, creazione e accesso ai dati strutturati.

Scopri come i puntatori interagiscono con le struct, comprendi l'importanza di questa connessione e padroneggia tecniche fondamentali come l'allocazione dinamica e il passaggio di struct alle funzioni

Acquisizione di una solida comprensione di come le struct vengono memorizzate in memoria, esplorazione dell'allineamento e del padding, e analisi di come le union aiutano a gestire efficientemente i dati condivisi.

Approfondimento sui modelli avanzati di struct, inclusi struct annidati e anonimi, esplorazione di modalità pratiche per combinarli con array e familiarizzazione con le strutture dati comuni.

Acquisire sicurezza implementando una lista collegata da zero, esplorare la sua struttura e creare funzioni essenziali per l'aggiunta, la traversata e la gestione degli elementi della lista.

Concetto di Base e Struttura

Soluzione