Summary  
This chapter explains how to declare and use anonymous structures and unions in C, enabling nested unnamed types that share memory and provide multiple views of the same data.

General domain of usage  
ASCII table generation

Il linguaggio di programmazione C dispone di **struct anonime** e **union anonime**, che permettono di definire struct e union **senza specificare un nome**.

## Cosa sono le struct e le union anonime?

Una union anonima o una struct anonima non possiede un identificatore. Per questo motivo, non è possibile creare variabili autonome di quel tipo; vengono invece utilizzate tipicamente all'interno di altre struct.

```
// Anonymous union
union {
    char x;
    int y;
};

// Anonymous structure
struct {
    char x;
    int y;
};
```


Le struct e le union anonime sono particolarmente utili quando sono annidate e verranno utilizzate solo nel contesto in cui sono dichiarate.

## Esempio pratico

Considerare uno scenario in cui si desidera rappresentare una tabella ASCII in cui lo stesso valore può essere interpretato come codice numerico o come simbolo carattere. Utilizzare una union anonima all'interno di una struttura consente di passare in modo efficiente tra queste due interpretazioni.

I2luY2x1ZGUgPHN0ZGlvLmg+CgpzdHJ1Y3QgQVNDSUl0YWJsZSB7CiAgICAvLyBBbm9ueW1vdXMgdW5pb24gYWxsb3dzIGR1YWwgcmVwcmVzZW50YXRpb24gb2YgdGhlIHNhbWUgbWVtb3J5CiAgICB1bmlvbiB7CiAgICAgICAgY2hhciBzeW1ib2w7CiAgICAgICAgaW50IG51bTsKICAgIH07Cn07CgppbnQgbWFpbigpIHsKICAgIHN0cnVjdCBBU0NJSXRhYmxlIEFadGFibGU7CiAgICBBWnRhYmxlLm51bSA9IDY1OyAvLyBBU0NJSSBjb2RlIGZvciAnQScKCiAgICAvLyBQcmludCBhbGwgdXBwZXJjYXNlIGxldHRlcnMgYW5kIHRoZWlyIG51bWVyaWMgY29kZXMKICAgIGZvciAoaW50IGkgPSAwOyBpIDwgMjY7IGkrKykgewogICAgICAgIHByaW50ZigibnVtID0gJWQgfCBzeW1ib2wgPSBgJWNgXG4iLCBBWnRhYmxlLm51bSArIGksIEFadGFibGUuc3ltYm9sICsgaSk7CiAgICB9CgogICAgcmV0dXJuIDA7Cn0=

In questo esempio, la struttura `ASCIItable` contiene una union anonima. La union permette di interpretare la stessa area di memoria sia come valore numerico (`num`) sia come carattere (`symbol`).

Quando `AZtable.num` viene impostato a 65, corrisponde al codice ASCII di `'A'`. Utilizzando la stessa memoria, `AZtable.symbol` rappresenta anch'esso `'A'`. Iterando 26 volte, è possibile stampare tutte le lettere maiuscole insieme ai rispettivi codici ASCII, dimostrando come **la stessa memoria possa rappresentare più viste dei dati**.

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

struct Point {
    struct {
        float x;
        float y;
    };
};

int findFurthestPoint(struct Point points[], int n);

TEST_CASE("Furthest point in normal points") {
    struct Point points[4] = {
        {1.0f, 2.0f},
        {3.0f, 4.0f},
        {0.0f, 5.0f},
        {6.0f, 1.0f}
    };
    // Расстояния: sqrt(5)=2.236, sqrt(25)=5, sqrt(25)=5, sqrt(37)=6.082
    int index = findFurthestPoint(points, 4);
    REQUIRE(index == 3); // (6,1)
}

TEST_CASE("Furthest point on X axis") {
    struct Point points[3] = {
        {0.0f, 0.0f},
        {10.0f, 0.0f},
        {5.0f, 0.0f}
    };
    int index = findFurthestPoint(points, 3);
    REQUIRE(index == 1); // (10,0)
}

TEST_CASE("Furthest point on Y axis") {
    struct Point points[3] = {
        {0.0f, 0.0f},
        {0.0f, 7.0f},
        {0.0f, 3.0f}
    };
    int index = findFurthestPoint(points, 3);
    REQUIRE(index == 1); // (0,7)
}

TEST_CASE("Furthest point with negative coordinates") {
    struct Point points[3] = {
        {-3.0f, -4.0f}, // distance 5
        {-5.0f, 0.0f},  // distance 5
        {0.0f, -6.0f}   // distance 6
    };
    int index = findFurthestPoint(points, 3);
    REQUIRE(index == 2); // (0,-6)
}

TEST_CASE("All points at origin") {
    struct Point points[3] = {
        {0.0f, 0.0f},
        {0.0f, 0.0f},
        {0.0f, 0.0f}
    };
    int index = findFurthestPoint(points, 3);
    REQUIRE(index == 0); // first point
}

TEST_CASE("Single point") {
    struct Point points[1] = {
        {2.0f, 3.0f}
    };
    int index = findFurthestPoint(points, 1);
    REQUIRE(index == 0);
}

TEST_CASE("Multiple points at the same maximum distance") {
    struct Point points[4] = {
        {3.0f, 4.0f}, // distance 5
        {-3.0f, -4.0f}, // distance 5
        {0.0f, 5.0f}, // distance 5
        {0.0f, 0.0f}  // distance 0
    };
    int index = findFurthestPoint(points, 4);
    REQUIRE(index == 0); // функция возвращает первый, кто достиг maxDistance
}

TEST_CASE("Large distances") {
    struct Point points[3] = {
        {1000.0f, 1000.0f},
        {2000.0f, 1500.0f},
        {-3000.0f, 2500.0f}
    };
    int index = findFurthestPoint(points, 3);
    REQUIRE(index == 2); // sqrt(3000^2 + 2500^2)=3905.1
}

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.

Struct e Union Anonime

Cosa sono le struct e le union anonime?

Esempio pratico

Soluzione