Structs en C++: agrupa datos relacionados en un solo tipo

Por qué agrupar datos

Hasta ahora cada variable iba por su cuenta: un int aquí, un string allá. Pero los programas reales tratan con cosas formadas por varias piezas: un punto tiene una x y una y, un estudiante tiene un nombre, una edad y un promedio. Pasar todo eso como variables sueltas y separadas es propenso a errores; nada las mantiene unidas, y una función que necesite las tres debe recibir los tres parámetros.

Un struct soluciona esto. Define un nuevo tipo que agrupa variables relacionadas —sus miembros— en una sola unidad. Una vez definido, tratas todo el conjunto como un único valor que puedes almacenar, copiar y pasar a funciones.

#include <iostream>
#include <string>
using namespace std;

struct Student {
    string name;
    int age;
    double gpa;
};   // <- no olvides el punto y coma tras la llave de cierre

int main() {
    Student s;          // un objeto que contiene los tres miembros
    s.name = "Ada";
    s.age = 19;
    s.gpa = 3.9;

    cout << s.name << " is " << s.age << " (GPA " << s.gpa << ")\n";
}

Accedes a cada miembro con el operador punto (s.name, s.age). El punto y coma tras la } de cierre de la definición de un struct es obligatorio; omitirlo es uno de los errores de compilación más habituales entre principiantes en C++.

Inicializar un struct

Asignar cada campo a mano funciona, pero es verboso y es fácil olvidar un miembro. La opción más limpia es la inicialización por agregados: enumera los valores entre llaves, en el mismo orden en que se declararon los miembros.

#include <iostream>
using namespace std;

struct Point {
    int x;
    int y;
};

int main() {
    Point a{3, 4};        // x = 3, y = 4 (init con llaves, preferida)
    Point origin{};       // ambos miembros inicializados por valor a 0
    Point b = {10, 20};   // forma antigua = {}, mismo efecto

    cout << a.x << "," << a.y << "\n";          // 3,4
    cout << origin.x << "," << origin.y << "\n"; // 0,0
    cout << b.x << "," << b.y << "\n";           // 10,20
}

Cuidado con el caso por defecto vacío: Point p; (sin llaves) deja x e y con valores basura, porque los miembros de tipos integrados no se ponen a cero automáticamente. Point p{}; los inicializa por valor a 0. Prefiere las llaves. También puedes fijar valores por defecto directamente en la definición, de modo que incluso Point p; empiece limpio:

#include <iostream>
using namespace std;

struct Config {
    int width  = 800;     // inicializadores de miembro por defecto
    int height = 600;
    bool fullscreen = false;
};

int main() {
    Config c;             // usa todos los valores por defecto
    Config wide{1920};    // width sobrescrito, los demás conservan sus valores

    cout << c.width << "x" << c.height << "\n";        // 800x600
    cout << wide.width << "x" << wide.height << "\n";  // 1920x600
}

Structs como parámetros de funciones

Un struct es un único valor, así que una función puede recibir un solo parámetro en lugar de tres. Solo recuerda que pasar un struct por valor copia todos sus miembros. Para cualquier cosa más grande que un par de ints, pásalo por referencia const para evitar la copia: la misma regla que viste en la página de referencias.

#include <iostream>
#include <string>
using namespace std;

struct Student {
    string name;
    double gpa;
};

// const& evita copiar el string y promete no modificar s
void printStudent(const Student& s) {
    cout << s.name << ": " << s.gpa << "\n";
}

// devolver un struct está bien: el compilador elimina la copia
Student makeStudent(string name, double gpa) {
    return Student{name, gpa};
}

int main() {
    Student top = makeStudent("Grace", 4.0);
    printStudent(top);
}

Devolver un struct completo desde una función es la manera idiomática de retornar varios valores a la vez, mucho más limpia que manejar varias referencias de salida.

Añadir funciones miembro y constructores

Un struct no se limita a datos. Puede contener funciones miembro que operan sobre sus propios miembros, y un constructor que inicializa el objeto en el momento en que se crea. Aquí es donde un struct empieza a parecerse a un pequeño objeto con comportamiento.

#include <iostream>
using namespace std;

struct Rectangle {
    double width;
    double height;

    // constructor: se ejecuta cuando se crea un Rectangle
    Rectangle(double w, double h) : width(w), height(h) {}

    // función miembro: usa los miembros del propio objeto
    double area() const {        // const = "no modifico el objeto"
        return width * height;
    }
};

int main() {
    Rectangle r(4.0, 5.0);
    cout << "area = " << r.area() << "\n";   // area = 20
}

Dentro de una función miembro se accede a los miembros por su nombre (width, height): se refieren a la copia de este objeto. Marcar area() const le indica al compilador que la función solo lee el objeto, lo que te permite llamarla también sobre valores const Rectangle. Los constructores son un tema en sí mismos, incluida esa sintaxis de lista de inicialización : width(w); la página de constructores lo trata en profundidad.

Struct vs. class: la diferencia real

Puede que hayas oído que "los structs son para datos y las clases para objetos". Eso es una convención, no una regla del lenguaje. En C++ un struct y una class son casi lo mismo: la única diferencia integrada es el nivel de acceso por defecto.

struct S {
    int x;        // public por defecto
};

class C {
    int x;        // private por defecto
};

Los miembros de un struct son public salvo que los marques de otra forma; los de una class empiezan siendo private. Eso es todo: ambos pueden tener constructores, funciones miembro, herencia y todo lo demás. Incluso puedes añadir especificadores de acceso explícitos a un struct para ocultar miembros:

#include <iostream>
using namespace std;

struct Counter {
    int value() const { return count; }   // público
    void bump() { count++; }

private:
    int count = 0;                          // ahora oculto
};

int main() {
    Counter c;
    c.bump();
    c.bump();
    cout << c.value() << "\n";   // 2
    // c.count = 99;   // error de compilación - count es privado
}

La conclusión práctica: usa struct para agrupaciones transparentes de datos donde cada campo está pensado para tocarse libremente (un Point, un Color, un registro de configuración), y recurre a class cuando quieras proteger el estado interno tras una interfaz pública. El compilador los trata igual; la palabra clave solo expresa tu intención.

Arreglos y vectores de structs

Como un struct es un tipo normal y corriente, puedes meter muchos de ellos en un arreglo o un vector y recorrerlos como cualquier otro valor.

#include <iostream>
#include <vector>
#include <string>
using namespace std;

struct Product {
    string name;
    double price;
};

int main() {
    vector<Product> cart = {
        {"Keyboard", 49.99},
        {"Mouse", 19.99},
        {"Monitor", 199.00},
    };

    double total = 0;
    for (const Product& p : cart) {   // const& - sin copia por elemento
        cout << p.name << ": $" << p.price << "\n";
        total += p.price;
    }
    cout << "Total: $" << total << "\n";
}

Fíjate en las llaves anidadas: cada {"Keyboard", 49.99} inicializa por agregados un Product, y las llaves exteriores construyen el vector. Usar const Product& en el bucle basado en rangos evita copiar cada struct en cada iteración; si quitas el & duplicarías cada elemento innecesariamente.

Siguiente: Enums

Los structs te permiten construir un tipo a partir de varios valores agrupados. El próximo capítulo va en sentido contrario: un enum define un tipo que puede contener exactamente un valor de un conjunto pequeño y con nombre, perfecto para cosas como Color::Red, Direction::North o el estado de una máquina de estados. Verás cómo enum class te da constantes legibles y con seguridad de tipos que combinan de forma natural con los structs y clases que ahora estás construyendo.