Structs em C++: agrupe dados relacionados em um único tipo

Por que agrupar dados

Até agora cada variável ficava por conta própria: um int aqui, uma string ali. Mas programas reais lidam com coisas compostas de várias partes: um ponto tem um x e um y, um estudante tem um nome, uma idade e um GPA. Passar tudo isso como variáveis soltas e separadas é propenso a erros; nada as mantém unidas, e uma função que precisa das três precisa receber os três parâmetros.

Uma struct resolve isso. Ela define um novo tipo que reúne variáveis relacionadas — seus membros — em uma única unidade. Uma vez definida, você trata o conjunto inteiro como um único valor que pode armazenar, copiar e passar para funções.

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

struct Student {
    string name;
    int age;
    double gpa;
};   // <- não esqueça o ponto e vírgula após a chave de fechamento

int main() {
    Student s;          // um objeto contendo os três membros
    s.name = "Ada";
    s.age = 19;
    s.gpa = 3.9;

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

Você acessa cada membro com o operador ponto (s.name, s.age). O ponto e vírgula após a } de fechamento da definição de uma struct é obrigatório; omiti-lo é um dos erros de compilação mais comuns entre iniciantes em C++.

Inicializando uma struct

Atribuir cada campo manualmente funciona, mas é verboso e é fácil esquecer um membro. A opção mais limpa é a inicialização por agregado: liste os valores entre chaves, na mesma ordem em que os membros foram declarados.

#include <iostream>
using namespace std;

struct Point {
    int x;
    int y;
};

int main() {
    Point a{3, 4};        // x = 3, y = 4 (init com chaves, preferida)
    Point origin{};       // ambos os membros inicializados por valor em 0
    Point b = {10, 20};   // forma antiga = {}, efeito idêntico

    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 com o caso padrão vazio: Point p; (sem chaves) deixa x e y com valores de lixo, porque membros de tipos embutidos não são zerados automaticamente. Point p{}; os inicializa por valor em 0. Prefira as chaves. Você também pode embutir valores padrão diretamente na definição, de modo que até Point p; comece limpo:

#include <iostream>
using namespace std;

struct Config {
    int width  = 800;     // inicializadores de membro padrão
    int height = 600;
    bool fullscreen = false;
};

int main() {
    Config c;             // usa todos os valores padrão
    Config wide{1920};    // width sobrescrito, os demais mantêm os padrões

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

Structs como parâmetros de funções

Uma struct é um único valor, então uma função pode receber um parâmetro em vez de três. Apenas lembre que passar uma struct por valor copia todos os membros. Para qualquer coisa maior que alguns ints, passe por referência const para evitar a cópia: a mesma regra que você viu na página de referências.

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

struct Student {
    string name;
    double gpa;
};

// const& evita copiar a string e promete não modificar s
void printStudent(const Student& s) {
    cout << s.name << ": " << s.gpa << "\n";
}

// retornar uma struct está OK - o compilador elimina a cópia
Student makeStudent(string name, double gpa) {
    return Student{name, gpa};
}

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

Retornar uma struct inteira de uma função é a maneira idiomática de devolver vários valores de uma vez, muito mais limpa do que gerenciar várias referências de saída.

Adicionando funções membro e construtores

Uma struct não se limita a dados. Ela pode conter funções membro que operam sobre seus próprios membros, e um construtor que inicializa o objeto no momento em que ele é criado. É aqui que uma struct começa a parecer um pequeno objeto com comportamento.

#include <iostream>
using namespace std;

struct Rectangle {
    double width;
    double height;

    // construtor: executa quando um Rectangle é criado
    Rectangle(double w, double h) : width(w), height(h) {}

    // função membro: usa os próprios membros do objeto
    double area() const {        // const = "eu não modifico o objeto"
        return width * height;
    }
};

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

Dentro de uma função membro, os membros são acessados pelo nome (width, height): eles se referem à cópia deste objeto. Marcar area() const diz ao compilador que a função apenas lê o objeto, o que permite chamá-la também sobre valores const Rectangle. Construtores são um tópico por si só, incluindo aquela sintaxe de lista de inicialização : width(w); a página de construtores aprofunda o assunto.

Struct vs. class: a real diferença

Você talvez já tenha ouvido que "structs são para dados, classes são para objetos". Isso é uma convenção, não uma regra da linguagem. Em C++ uma struct e uma class são quase a mesma coisa: a única diferença embutida é o nível de acesso padrão.

struct S {
    int x;        // public por padrão
};

class C {
    int x;        // private por padrão
};

Os membros de uma struct são public a menos que você os marque de outra forma; os de uma class começam como private. É isso: ambos podem ter construtores, funções membro, herança e tudo mais. Você pode até adicionar especificadores de acesso explícitos a uma struct para ocultar membros:

#include <iostream>
using namespace std;

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

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

int main() {
    Counter c;
    c.bump();
    c.bump();
    cout << c.value() << "\n";   // 2
    // c.count = 99;   // erro de compilação - count é privado
}

A conclusão prática: use struct para conjuntos transparentes de dados em que cada campo deve ser acessado livremente (um Point, uma Color, um registro de configuração), e recorra a class quando quiser proteger o estado interno por trás de uma interface pública. O compilador os trata da mesma forma; a palavra-chave apenas sinaliza sua intenção.

Arrays e vectors de structs

Como uma struct é um tipo comum, você pode colocar muitas delas em um array ou em um vector e percorrê-las como qualquer outro 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& - sem cópia por item
        cout << p.name << ": $" << p.price << "\n";
        total += p.price;
    }
    cout << "Total: $" << total << "\n";
}

Observe as chaves aninhadas: cada {"Keyboard", 49.99} inicializa por agregado um Product, e as chaves externas constroem o vector. Usar const Product& no laço baseado em intervalo evita copiar cada struct a cada iteração; remova o & e você duplicaria cada elemento desnecessariamente.

Próximo: Enums

Structs permitem construir um tipo a partir de vários valores agrupados. O próximo capítulo segue o caminho oposto: um enum define um tipo que pode conter exatamente um valor de um conjunto pequeno e nomeado, perfeito para coisas como Color::Red, Direction::North ou o status de uma máquina de estados. Você verá como enum class oferece constantes legíveis e com segurança de tipos que combinam naturalmente com as structs e classes que você está construindo agora.