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

El lenguaje de programación C incluye **estructuras anónimas** y **uniones anónimas**, que permiten definir estructuras y uniones **sin especificar un nombre**.

## ¿Qué son las estructuras y uniones anónimas?

Una unión anónima o estructura anónima no tiene un identificador. Por esta razón, no es posible crear variables independientes de ese tipo; en su lugar, suelen utilizarse dentro de otras estructuras.

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

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


Las estructuras y uniones anónimas son especialmente útiles cuando están anidadas y solo se utilizarán en el contexto donde se declaran.

## Ejemplo práctico

Considera un escenario en el que deseas representar una tabla ASCII donde el mismo valor puede interpretarse como un código numérico o como un símbolo de carácter. Utilizar una unión anónima dentro de una estructura permite alternar entre estas dos interpretaciones de manera eficiente.

I2luY2x1ZGUgPHN0ZGlvLmg+CgpzdHJ1Y3QgQVNDSUl0YWJsZSB7CiAgICAvLyBBbm9ueW1vdXMgdW5pb24gYWxsb3dzIGR1YWwgcmVwcmVzZW50YXRpb24gb2YgdGhlIHNhbWUgbWVtb3J5CiAgICB1bmlvbiB7CiAgICAgICAgY2hhciBzeW1ib2w7CiAgICAgICAgaW50IG51bTsKICAgIH07Cn07CgppbnQgbWFpbigpIHsKICAgIHN0cnVjdCBBU0NJSXRhYmxlIEFadGFibGU7CiAgICBBWnRhYmxlLm51bSA9IDY1OyAvLyBBU0NJSSBjb2RlIGZvciAnQScKCiAgICAvLyBQcmludCBhbGwgdXBwZXJjYXNlIGxldHRlcnMgYW5kIHRoZWlyIG51bWVyaWMgY29kZXMKICAgIGZvciAoaW50IGkgPSAwOyBpIDwgMjY7IGkrKykgewogICAgICAgIHByaW50ZigibnVtID0gJWQgfCBzeW1ib2wgPSBgJWNgXG4iLCBBWnRhYmxlLm51bSArIGksIEFadGFibGUuc3ltYm9sICsgaSk7CiAgICB9CgogICAgcmV0dXJuIDA7Cn0=

En este ejemplo, la estructura `ASCIItable` contiene una unión anónima. La unión permite que la misma memoria se interprete tanto como un valor numérico (`num`) como un carácter (`symbol`).

Cuando `AZtable.num` se establece en 65, corresponde al código ASCII de `'A'`. Usando la misma memoria, `AZtable.symbol` también representa `'A'`. Al iterar 26 veces, se pueden imprimir todas las letras mayúsculas junto con sus códigos ASCII, demostrando cómo **la misma memoria puede representar múltiples vistas de los datos**.

#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

Adquiere una comprensión sólida de cómo funcionan las estructuras (structs) en C, desde definiciones básicas hasta conceptos avanzados de memoria. Explora cómo los punteros interactúan con datos estructurados, descubre formas eficientes de organizar información y gana confianza implementando estructuras de datos reales como listas enlazadas.

Explora los fundamentos de las estructuras, comprende por qué se utilizan y adquiere confianza al definir, crear y acceder a datos estructurados.

Descubre cómo los punteros interactúan con las estructuras, aprende por qué esta conexión es importante y domina técnicas clave como la asignación dinámica y el paso de estructuras a funciones

Adquisición de una comprensión sólida sobre cómo se almacenan las estructuras en la memoria, exploración del alineamiento y el relleno, y análisis de cómo las uniones ayudan a gestionar datos compartidos de manera eficiente.

Profundización en patrones avanzados de structs, incluyendo structs anidados y anónimos, exploración de formas prácticas de combinarlos con arreglos y familiarización con estructuras de datos comunes.

Desarrolla confianza al implementar una lista enlazada desde cero, explora su estructura y crea funciones esenciales para agregar, recorrer y gestionar los elementos de la lista.

Struct y Union Anónimos

¿Qué son las estructuras y uniones anónimas?

Ejemplo práctico

Solución