📐 Tipos: Estruturas, Uniões e Tipos Enumerados · C/C++

📐 Tipos: Estruturas, Uniões e Tipos Enumerados

"Além dos tipos primitivos, C e C++ permitem que o programador crie seus próprios tipos de dados, agrupando variáveis relacionadas sob um único nome."

Os tipos definidos pelo usuário são fundamentais para organizar dados complexos e tornar o código mais expressivo e fácil de manter. Os três principais mecanismos para isso são estruturas (struct), uniões (union) e tipos enumerados (enum).

🏗️ Estruturas (struct)

Uma estrutura é um tipo de dado que agrupa múltiplas variáveis (chamadas membros ou campos), que podem ser de tipos diferentes, sob um único nome.

📝 Declaração e Uso

// Definindo uma estrutura para representar um ponto no plano
struct Ponto {
    int x;
    int y;
};

// Definindo uma estrutura mais complexa
struct Aluno {
    char nome[50];
    int matricula;
    float notas[3];
};

int main() {
    // Declarando variáveis do tipo struct
    struct Ponto p1;           // Estilo C (requer 'struct')
    Ponto p2;                 // Estilo C++ (não precisa de 'struct')
    
    // Acessando e atribuindo valores aos membros
    p1.x = 10;
    p1.y = 20;
    
    // Inicialização na declaração (C++11)
    Ponto p3 = {30, 40};
    Ponto p4{50, 60};        // Inicialização uniforme
    
    cout << "p1: (" << p1.x << ", " << p1.y << ")" << endl;
}
  

🧩 Estruturas Aninhadas

Uma estrutura pode conter membros que são outras estruturas.

struct Data {
    int dia;
    int mes;
    int ano;
};

struct Pessoa {
    char nome[60];
    Data nascimento;      // Estrutura dentro de estrutura
    float altura;
};

// Acesso: pessoa.nascimento.dia = 15;
  

📏 Tamanho e Alinhamento

O tamanho de uma estrutura é pelo menos a soma dos tamanhos de seus membros, mas pode ser maior devido ao alinhamento de memória (padding). Use sizeof(struct) para obter o tamanho real.

✅ Vantagens das structs

Agrupamento lógico de dados relacionados
Facilita a passagem de múltiplos valores para funções
Base para estruturas de dados mais complexas
Melhora a legibilidade e organização do código

🔗 Uniões (union)

Uma união é semelhante a uma estrutura, mas todos os seus membros compartilham o mesmo espaço de memória. Apenas um membro pode armazenar um valor significativo por vez. O tamanho da união é o tamanho do seu maior membro.

union Dado {
    int i;
    float f;
    char c[4];
};

int main() {
    union Dado d;
    
    d.i = 65;                    // Armazena um inteiro
    cout << d.i << endl;          // 65
    
    d.f = 3.14f;                 // Sobrescreve o valor anterior
    cout << d.f << endl;          // 3.14
    cout << d.i << endl;          // Valor indefinido (lixo)
    
    cout << "Tamanho da union: " << sizeof(d) << endl;  // 4
}
  

🎯 Aplicações Comuns

Economia de memória em sistemas embarcados ou com recursos limitados.
Representação de variantes: um valor pode ser de diferentes tipos em momentos diferentes.
Manipulação de baixo nível: acessar a representação binária de um tipo (ex.: ver os bytes de um float).
Estruturas de dados genéricas (em conjunto com enum para identificar o tipo ativo).

🔢 Tipos Enumerados (enum)

Uma enumeração é um tipo definido pelo usuário que consiste em um conjunto de constantes inteiras nomeadas, tornando o código mais legível e menos propenso a erros.

📝 Enumeração Tradicional (C/C++)

// Definindo um enum para dias da semana
enum DiaSemana {
    DOMINGO,     // 0 (padrão)
    SEGUNDA,     // 1
    TERCA,       // 2
    QUARTA,      // 3
    QUINTA,      // 4
    SEXTA,       // 5
    SABADO       // 6
};

// Definindo valores específicos
enum Status {
    INATIVO = 0,
    ATIVO = 1,
    PENDENTE = 2,
    BLOQUEADO = 99
};

int main() {
    enum DiaSemana hoje = QUARTA;
    
    if (hoje == SABADO || hoje == DOMINGO) {
        cout << "É fim de semana!" << endl;
    }
}
  

🛡️ Enum Class (C++11) — Mais Seguro

O enum class (ou enum struct) resolve problemas do enum tradicional: evita conversões implícitas para inteiros e mantém os nomes em um escopo próprio.

enum class Cor {
    VERMELHO,
    VERDE,
    AZUL
};

enum class Sentido {
    NORTE,
    SUL,
    LESTE,
    OESTE
};

int main() {
    Cor c = Cor::VERMELHO;        // Escopo qualificado
    Sentido s = Sentido::NORTE;
    
    // if (c == 0) { }              // ERRO: não converte implicitamente
    if (c == Cor::VERMELHO) { }    // OK
    
    // Conversão explícita se necessário
    int valor = static_cast<int>(Cor::AZUL);  // 2
}
  

📊 Comparação Rápida

Característica	struct	union	enum
Propósito	Agrupar dados heterogêneos	Compartilhar memória entre tipos	Nomear constantes inteiras
Tamanho	Soma dos membros + padding	Tamanho do maior membro	Geralmente sizeof(int)
Membros ativos	Todos simultaneamente	Apenas um por vez	Um valor por vez
Uso principal	Modelagem de entidades	Economia de memória, variantes	Opções, estados, flags

🔗 Conclusão

Estruturas, uniões e tipos enumerados são ferramentas essenciais para qualquer programador C/C++. As estruturas organizam dados complexos, as uniões otimizam o uso de memória em situações específicas, e os enumerados tornam o código mais expressivo e seguro. Dominar esses tipos definidos pelo usuário é um passo importante para escrever código profissional e bem estruturado.

⏭️ Próximo: Declarando arrays...