Docs ejecutables de C: Estructuras

Q: ¿Cómo se declara una struct en C?

Escribe struct seguido de un nombre de etiqueta y una lista de miembros entre llaves: struct Point { int x; int y; };. Eso declara un tipo, no una variable. Para crear una variable escribes luego struct Point p;: en C la palabra struct es parte del nombre del tipo, que es por lo que casi todo el código la combina con un typedef.

Q: ¿Cuál es la diferencia entre `.` y `->` en las estructuras?

Usa . cuando tienes la estructura en sí (p.x) y -> cuando tienes un puntero a ella (ptr->x). La flecha es una abreviatura de (*ptr).x. Mira estructuras y punteros para los detalles.

Q: ¿Cómo inicializo una struct en C?

O bien por posición, struct Point p = {3, 4};, o bien con inicializadores designados, struct Point p = {.y = 4, .x = 3};. La forma designada nombra cada miembro, así que sobrevive a que alguien reordene la estructura después y deja a cero los miembros sin nombrar.

Un array contiene muchos valores de un tipo. Una struct hace lo contrario: contiene unos pocos valores de tipos distintos y los trata como una sola cosa. Un punto es una x y una y. Un empleado es un nombre, un identificador y un salario. Sin estructuras llevarías eso de un lado a otro como tres variables sueltas y esperarías no mezclar nunca de quién era cada salario.

Declarar un tipo estructura

La declaración de una estructura nombra una etiqueta y lista los miembros entre llaves:

struct Point {
    int x;
    int y;
};

El punto y coma tras la llave de cierre es obligatorio; olvidarlo produce uno de los mensajes de error más confusos con los que se topará un principiante de C, porque el compilador culpa a la línea siguiente.

Esto declara un tipo, no una variable. En C el nombre completo del tipo es struct Point, con la palabra clave incluida:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point p;
    p.x = 3;
    p.y = 4;

    printf("(%d, %d)\n", p.x, p.y);
    return 0;
}

Los miembros se leen y se escriben con el operador punto, p.x. Una variable de tipo estructura es una variable corriente: vive en la pila, se puede asignar a otra estructura del mismo tipo con =, y desaparece al final de su ámbito.

Escribir struct Point en todas partes cansa, y por eso casi todo el código C real envuelve la declaración en un typedef para que el tipo sea simplemente Point.

Inicializar una estructura

Puedes llenar una estructura en el momento de declararla. La forma posicional lista los valores en orden de declaración:

struct Point p = {3, 4};   // x = 3, y = 4

El inicializador designado nombra cada miembro en su lugar, lo que es más claro y más seguro:

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee a = {101, "Ada", 92000.0};
    struct Employee b = {.name = "Grace", .id = 102, .salary = 105000.0};
    struct Employee blank = {0};

    printf("%d %s %.2f\n", a.id, a.name, a.salary);
    printf("%d %s %.2f\n", b.id, b.name, b.salary);
    printf("%d [%s] %.2f\n", blank.id, blank.name, blank.salary);
    return 0;
}

Tres cosas que vale la pena notar:

La forma designada puede listar los miembros en cualquier orden, así que agregar o reordenar un miembro después no desplaza valores en silencio a las casillas equivocadas.
Cualquier miembro que omitas queda inicializado a cero: {0} es la forma idiomática de poner a cero una estructura entera.
Un miembro char name[32] es un array real dentro de la estructura, así que la cadena se guarda en la estructura misma y no en otro sitio. Eso también significa que a.name = "Ada"; después es ilegal; necesitas strcpy (mira funciones de cadenas).

Una estructura sin inicializador queda sin inicializar, y leer sus miembros antes de escribirlos es comportamiento indefinido. = {0} no cuesta nada y elimina toda esa categoría de errores.

Asignar y comparar

La asignación de estructuras copia cada miembro:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point a = {1, 2};
    struct Point b = a;   // copia completa

    b.x = 99;

    printf("a = (%d, %d)\n", a.x, a.y);
    printf("b = (%d, %d)\n", b.x, b.y);
    return 0;
}

a queda intacta: b recibió su propia copia. Pero fíjate en lo que C no te da: no hay == para estructuras. if (a == b) no compila. Comparar significa comparar miembros:

if (a.x == b.x && a.y == b.y) { /* iguales */ }

No recurras a memcmp como atajo. Los compiladores insertan bytes invisibles de relleno entre los miembros por alineación, y esos bytes pueden contener basura, así que dos estructuras con miembros idénticos pueden resultar distintas byte a byte.

Arrays de estructuras

Como una estructura es un tipo como cualquier otro, puedes hacer un array de ellas: la forma estándar de tener una tabla de registros.

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee staff[3] = {
        {101, "Ada",    92000.0},
        {102, "Grace",  105000.0},
        {103, "Alan",   87000.0},
    };

    int n = sizeof(staff) / sizeof(staff[0]);
    double total = 0.0;

    for (int i = 0; i < n; i++) {
        printf("%-3d %-8s %10.2f\n", staff[i].id, staff[i].name, staff[i].salary);
        total += staff[i].salary;
    }

    printf("Promedio: %.2f\n", total / n);
    return 0;
}

staff[i].salary se lee como "el elemento i, y luego su miembro salary": la indexación se asocia más fuerte que el punto, así que no hacen falta paréntesis.

Las estructuras se copian al entrar en una función

Esta es la regla que atrapa a la gente. Cuando pasas una estructura a una función, C la copia. La función trabaja sobre su propia copia privada:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

void try_to_move(struct Point p) {
    p.x += 100;   // cambia solo la copia
}

double distance_from_origin(struct Point p) {
    return p.x * p.x + p.y * p.y;   // distancia al cuadrado, sin necesidad de math.h
}

int main(void) {
    struct Point p = {3, 4};

    try_to_move(p);
    printf("tras try_to_move: (%d, %d)\n", p.x, p.y);
    printf("distancia al cuadrado: %.0f\n", distance_from_origin(p));
    return 0;
}

p sigue siendo (3, 4). Leer una estructura por valor, como hace distance_from_origin, está perfectamente bien y suele ser la opción más clara para estructuras pequeñas. Pero si la función debe cambiar la estructura de quien llama —o si la estructura es lo bastante grande como para que copiarla sea un derroche— pasa un puntero. Ese es el tema de estructuras y punteros.

Devolver una estructura por valor funciona igual y es completamente legal:

struct Point make_point(int x, int y) {
    struct Point p = {x, y};
    return p;
}

Estructuras anidadas

Un miembro de una estructura puede ser a su vez una estructura. Encadena los puntos para llegar dentro:

#include <stdio.h>

struct Date {
    int year;
    int month;
    int day;
};

struct Book {
    char title[64];
    struct Date published;
    int pages;
};

int main(void) {
    struct Book b = {
        .title = "El lenguaje de programacion C",
        .published = {.year = 1978, .month = 2, .day = 22},
        .pages = 228,
    };

    printf("%s (%d-%02d-%02d), %d paginas\n",
           b.title,
           b.published.year, b.published.month, b.published.day,
           b.pages);
    return 0;
}

b.published.year entra un nivel a la vez. El anidamiento es como construyes modelos de datos reales en C, y la estructura interna se guarda dentro de la externa, no se apunta a ella, así que el Book entero es un único bloque contiguo de memoria.

Tamaño, relleno y orden de los miembros

sizeof te dice cuán grande es una estructura, y la respuesta suele ser mayor que la suma de sus miembros:

#include <stdio.h>

struct Wasteful {
    char  a;    // 1 byte
    int   b;    // 4 bytes
    char  c;    // 1 byte
};

struct Tidy {
    int   b;
    char  a;
    char  c;
};

int main(void) {
    printf("Wasteful: %zu bytes\n", sizeof(struct Wasteful));
    printf("Tidy:     %zu bytes\n", sizeof(struct Tidy));
    return 0;
}

En una máquina típica Wasteful ocupa 12 bytes y Tidy ocupa 8, aunque ambas contienen los mismos tres miembros. El compilador inserta relleno para que cada miembro quede en una dirección que le guste a su tipo: un int normalmente quiere un múltiplo de 4. Agrupar los miembros grandes antes que los pequeños tiende a empaquetar mejor.

Esto importa pocas veces (un array de un millón de elementos, la disposición de un paquete de red) y nunca para la corrección de tu propio código. Lo que sí explica es por qué sizeof te sorprende, y por qué usar memcmp sobre estructuras es mala idea.

Preguntas frecuentes

¿Cómo se declara una struct en C?

Escribe struct seguido de un nombre de etiqueta y una lista de miembros entre llaves: struct Point { int x; int y; };. Eso declara un tipo, no una variable. Para crear una variable escribes luego struct Point p;: en C la palabra struct es parte del nombre del tipo, que es por lo que casi todo el código la combina con un typedef.

¿Cuál es la diferencia entre . y -> en las estructuras?

Usa . cuando tienes la estructura en sí (p.x) y -> cuando tienes un puntero a ella (ptr->x). La flecha es una abreviatura de (*ptr).x. Mira estructuras y punteros para los detalles.

¿Las estructuras se pasan por valor o por referencia en C?

Por valor, siempre. Pasar una estructura a una función copia cada miembro, así que los cambios dentro de la función no afectan a la variable de quien llama. Para mutar el original —o para evitar copiar una estructura grande— pasa un puntero.

¿Cómo inicializo una struct en C?

O bien por posición, struct Point p = {3, 4};, o bien con inicializadores designados, struct Point p = {.y = 4, .x = 3};. La forma designada nombra cada miembro, así que sobrevive a que alguien reordene la estructura después y deja a cero los miembros sin nombrar.

Conceptos relacionados