Summary  
This chapter covers how to traverse a singly linked list by iterating from the head node with a while loop until reaching NULL, printing each node’s data field.

General domain of usage  
Data structure manipulation and inspection

Dopo aver imparato come creare e collegare i nodi, è necessario verificare che la lista funzioni correttamente!

Per fare ciò, scriviamo una semplice funzione che visualizzerà l'intera lista.

La funzione accetterà un puntatore all'area di memoria dove è memorizzato il nodo head (primo) della lista.
```
void printList(struct Node* head) {}
```
Successivamente verrà creato un nodo temporaneo current, con il quale attraverseremo l'intera lista. Il contenuto del nodo current sarà uguale al contenuto del nodo corrente della lista.
```
struct Node* current = head;
```

Per scorrere la lista, utilizziamo il ciclo **while(){}** con la condizione necessaria, ovvero, fino a quando non si trova un nodo il cui campo next è **NULL**.

Il nodo **temp** (temporaneo) svolge il ruolo di nodo buffer. Serve per **memorizzare temporaneamente** (e cancellare) il contenuto del nodo corrente. **Se cancelliamo immediatamente il nodo corrente, perderemo la connessione con il nodo successivo, il che significa che l'accesso alla lista sarà perso.**


Nota

```
while (current != NULL) { }
printf("\n");
```
All'interno del ciclo, visualizzeremo il contenuto del campo data del nodo corrente e cambieremo il campo next per passare al nodo successivo.

```
printf("%d ", current->data);
current = current->next;
```


Non appena viene trovato un nodo il cui campo next è uguale a NULL, il ciclo interrompe la visualizzazione del contenuto dei nodi e la funzione termina.

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

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

struct Node* createNode(int value);
void addNewNode(struct Node** head, int value);
void printList(struct Node* head);
void freeList(struct Node* head);

// Helper: capture stdout
std::string capturePrintList(struct Node* head) {
    char buffer[1024] = {0};
    FILE* old_stdout = stdout;
    FILE* temp = fmemopen(buffer, sizeof(buffer), "w");
    stdout = temp;

    printList(head);

    fflush(temp);
    fclose(temp);
    stdout = old_stdout;

    return std::string(buffer);
}

// Helper: build list from array
struct Node* buildList(const int* values, int n) {
    struct Node* head = nullptr;
    for (int i = 0; i < n; i++) {
        addNewNode(&head, values[i]);
    }
    return head;
}

TEST_CASE("printList outputs correct elements") {
    int values[] = {1, 2, 3, 4};
    struct Node* head = buildList(values, 4);

    std::string output = capturePrintList(head);
    REQUIRE(output == R"(1 2 3 4 
)");

    freeList(head);
}

TEST_CASE("printList on empty list") {
    struct Node* head = nullptr;
    std::string output = capturePrintList(head);
    REQUIRE(output == R"(
)"); // пустая строка с переносом
}

TEST_CASE("freeList does not crash on multiple nodes") {
    int values[] = {10, 20, 30};
    struct Node* head = buildList(values, 3);

    // Просто вызываем freeList, проверяем, что не падает
    REQUIRE_NOTHROW(freeList(head));
}

TEST_CASE("freeList works on empty list") {
    struct Node* head = nullptr;
    REQUIRE_NOTHROW(freeList(head));
}

TEST_CASE("printList after adding nodes incrementally") {
    struct Node* head = nullptr;
    addNewNode(&head, 5);
    addNewNode(&head, 10);
    addNewNode(&head, 15);

    std::string output = capturePrintList(head);
    REQUIRE(output == R"(5 10 15 
)");

    freeList(head);
}

TEST_CASE("printList with negative and zero values") {
    int values[] = {0, -1, -20};
    struct Node* head = buildList(values, 3);

    std::string output = capturePrintList(head);
    REQUIRE(output == R"(0 -1 -20 
)");

    freeList(head);
}

TEST_CASE("printList with large number of nodes") {
    const int N = 100;
    int values[N];
    for (int i = 0; i < N; i++) values[i] = i;

    struct Node* head = buildList(values, N);

    std::string output = capturePrintList(head);

    std::string expected;
    for (int i = 0; i < N; i++) expected += std::to_string(i) + " ";
    expected += R"(
)";

    REQUIRE(output == expected);

    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.

Attraversamento e Visualizzazione di una Lista Collegata

Soluzione