Struct

O problema

A secretaria precisa guardar o nome e a nota de cada aluno. Uma primeira solução usa dois vetores: nomes[] e notas[]. O aluno i é representado pela dupla nomes[i] e notas[i].

Agora alguém ordena só o vetor de notas. Os nomes ficam na posição antiga, e o boletim passa a atribuir a nota de uma pessoa a outra. Ninguém trocou um dado sequer, mas a associação entre eles se perdeu.

Como representar cada aluno para que nome e nota sejam copiados, trocados e ordenados sempre juntos?

Antes da teoria: desenhe como três alunos ficariam na memória com dois vetores e depois com uma única “ficha” por aluno. Qual desenho torna impossível separar nome e nota?

Conceitos centrais

Uma struct define um novo tipo que agrupa campos relacionados. Cada campo tem nome e tipo próprios. Uma variável desse tipo é um registro: um bloco contínuo de memória que guarda todos os campos (o compilador pode deixar alguns bytes vazios entre eles, por questão de alinhamento).

struct Aluno {
    char nome[50];
    float nota;
};                       // o ponto e vírgula é obrigatório

struct Aluno a;          // variável do tipo struct Aluno
a.nota = 8.5f;           // operador . acessa um campo

Tipo

struct Aluno descreve o formato do registro. Declarar o tipo não reserva memória.

Variável

a é um registro concreto, com espaço para todos os campos.

Campo

nome e nota são acessados com a.nome e a.nota.

typedef: um nome mais curto

typedef cria um apelido para um tipo. Com ele, não é preciso repetir a palavra struct.

typedef struct {
    char nome[50];
    float nota;
} Aluno;

Aluno a = {"Ana", 8.5f};                    // inicialização posicional
Aluno b = {.nota = 7.0f, .nome = "Bruno"};  // inicialização designada (C99)
Aluno c = {0};                              // todos os campos zerados

Na inicialização posicional, os valores seguem a ordem dos campos. Na designada, você nomeia o campo e a ordem deixa de importar. Os campos omitidos recebem zero.

Structs dentro de structs

Um campo pode ser outra struct. O acesso encadeia operadores ., da variável mais externa para a mais interna.

struct Data { int dia, mes, ano; };
struct Evento { char titulo[40]; struct Data quando; };

struct Evento prova = {"Prova 1", {14, 10, 2026}};
prova.quando.mes = 11;   // evento → data → mês

Na prática

#include <stdio.h>

typedef struct {
    char nome[50];
    float nota;
} Aluno;

int main(void) {
    Aluno aluno = {"Ana", 8.5f};
    aluno.nota = 9.0f;
    printf("%s: %.1f\n", aluno.nome, aluno.nota);
    return 0;
}

Saída: Ana: 9.0

Vetor de structs: uma ficha por aluno

Aluno turma[3] = {
    {"Ana", 8.5f},
    {"Bruno", 6.0f},
    {"Carla", 9.0f}
};

for (int i = 0; i < 3; i++) {
    if (turma[i].nota >= 7.0f) {
        printf("%s\n", turma[i].nome);
    }
}

Leia turma[i].nota da esquerda para a direita: primeiro escolha o registro pelo índice e depois o campo. Com nota mínima 7, a saída contém Ana e Carla.

A cópia é independente

Aluno copia = turma[0];             // copia nome e nota
copia.nota = 10.0f;                 // altera somente a cópia

printf("copia:    %s %.1f\n", copia.nome, copia.nota);
printf("turma[0]: %s %.1f\n", turma[0].nome, turma[0].nota);

Saída: copia: Ana 10.0 e turma[0]: Ana 8.5

A atribuição criou um segundo registro com os mesmos valores, inclusive uma cópia própria do vetor nome. Por isso, mudar a nota da cópia não afeta turma[0].

Struct e funções

Em C, todo argumento é passado por valor. Passar uma struct copia o registro inteiro para a função. Para alterar o original, passe o endereço e use ->. A aula de ponteiros detalha esse mecanismo.

Há uma exceção aparente: um vetor passado para uma função não é copiado. A função recebe o endereço do primeiro elemento e trabalha sobre os dados originais. Por isso, relatorio(turma, 3), no exercício 3, não copia a turma.

void bonus_errado(Aluno a, float bonus) {
    a.nota += bonus;          // altera apenas a cópia local
}

void aplicar_bonus(Aluno *a, float bonus) {
    a->nota += bonus;         // a->nota equivale a (*a).nota
    if (a->nota > 10.0f) a->nota = 10.0f;
}

// Chamada: aplicar_bonus(&turma[1], 1.0f);  Bruno passa de 6.0 para 7.0

Comparar registros: crie a sua regra

Com inteiros, “estar em ordem” é óbvio: 3 vem antes de 7. Com registros, não é. Um aluno vem antes de outro por causa da nota, do nome ou da matrícula? E se as notas forem iguais? O C não sabe responder, porque if (a < b) nem compila para structs. Quem decide a ordem é você, e a forma mais organizada de decidir é escrever essa regra como uma função.

Vamos montar o ranking da turma com esta regra:

1. Critério principal: quem tem a maior nota aparece primeiro.
2. Desempate: com notas iguais, aparece primeiro quem vem antes em ordem alfabética.

A função recebe dois alunos e responde a uma única pergunta: “x deve aparecer antes de y na lista?” Ela retorna 1 para sim e 0 para não.

#include <string.h>

// Retorna 1 se x deve aparecer antes de y na lista; 0 caso contrário.
// Regra: maior nota primeiro. Em empate de nota, ordem alfabética do nome.
int vem_antes(const Aluno *x, const Aluno *y) {
    if (x->nota != y->nota) {          // 1) as notas decidem?
        return x->nota > y->nota;      //    sim: maior nota vem antes
    }
    return strcmp(x->nome, y->nome) < 0;   // 2) empate: o nome decide
}

Lendo a função linha a linha

const Aluno *

A função recebe o endereço de cada aluno, sem copiar o registro inteiro, que tem dezenas de bytes. (Curiosidade: sizeof(Aluno) costuma valer 56 em um compilador x64 comum, ou seja, 50 do nome, 2 bytes vazios de alinhamento e 4 da nota. O valor exato depende da plataforma.) O const garante que ela só lê e não altera nenhum dado.

->

Como x é um ponteiro, os campos são acessados com x->nota, que é o mesmo que (*x).nota.

Linha 1

Se as notas são diferentes, elas já decidem a ordem. Em C, x->nota > y->nota é uma expressão que vale 1 (verdadeiro) ou 0 (falso), e por isso pode ser retornada diretamente. Comparar float com != funciona bem para notas digitadas, como 8.5. Notas resultantes de contas podem ter pequenos erros de arredondamento (0.1 + 0.2 não dá exatamente 0.3), e aí duas notas “iguais” podem não empatar.

Linha 2

Só é executada se as notas forem iguais. strcmp(a, b) retorna um número negativo se a vem antes de b, zero se forem iguais e positivo se vier depois. Por isso, o teste é < 0. Atenção: strcmp compara os códigos dos caracteres, um a um. Isso coincide com a ordem alfabética para nomes sem acento e com a mesma convenção de maiúsculas, como os desta aula. Com acentos ou caixa misturada (“Ágata”, “ana”), a ordem pode sair diferente da do dicionário.

Usando a regra para ordenar

A vantagem aparece aqui: o algoritmo de ordenação não precisa saber nada sobre notas ou nomes. Ele só pergunta à regra quem vem antes. O código abaixo é o insertion sort, que você verá na aula 5. Repare que a única linha que fala de alunos é a chamada a vem_antes:

#include <stdio.h>
#include <string.h>

typedef struct {
    char nome[50];
    float nota;
} Aluno;

// A regra apresentada acima.
int vem_antes(const Aluno *x, const Aluno *y) {
    if (x->nota != y->nota) {
        return x->nota > y->nota;
    }
    return strcmp(x->nome, y->nome) < 0;
}

void ordenar_turma(Aluno t[], int n) {
    for (int i = 1; i < n; i++) {
        Aluno chave = t[i];
        int j = i - 1;
        while (j >= 0 && vem_antes(&chave, &t[j])) {   // a regra decide
            t[j + 1] = t[j];
            j--;
        }
        t[j + 1] = chave;
    }
}

int main(void) {
    Aluno turma[4] = {{"Davi", 8.5f}, {"Bruno", 6.0f}, {"Ana", 8.5f}, {"Carla", 9.0f}};
    ordenar_turma(turma, 4);
    for (int i = 0; i < 4; i++)
        printf("%d. %s %.1f\n", i + 1, turma[i].nome, turma[i].nota);
    return 0;
}

Saída: 1. Carla 9.0 · 2. Ana 8.5 · 3. Davi 8.5 · 4. Bruno 6.0

Davi estava antes de Ana no vetor original, mas os dois têm 8.5, e o desempate alfabético colocou Ana primeiro.

Exercícios progressivos

Os exercícios usam a mesma turma dos exemplos: Aluno turma[3] = {{"Ana", 8.5f}, {"Bruno", 6.0f}, {"Carla", 9.0f}};. Tente resolver cada um no papel ou no compilador antes de abrir a dica. A dica não entrega a resposta: ela aponta a pergunta certa a fazer.

Aluno simulado = turma[1];
simulado.nota = simulado.nota + 2.0f;
printf("%.1f %.1f\n", turma[1].nota, simulado.nota);

typedef struct {
    int codigo;          // identificador: número inteiro
    char nome[40];       // até 39 bytes de texto + '\0'
    float preco;         // valor com centavos
    int estoque;         // quantidade: se conta, então é int
} Produto;

Produto caderno = {.codigo = 101, .nome = "Caderno", .preco = 15.0f, .estoque = 10};
printf("%s (cod. %d): R$ %.2f - %d un.\n",
       caderno.nome, caderno.codigo, caderno.preco, caderno.estoque);

void relatorio(const Aluno t[], int n) {
    if (n == 0) {                       // evita divisão por zero
        printf("Turma vazia.\n");
        return;
    }
    float soma = 0.0f;
    int aprovados = 0;
    printf("Aprovados:\n");
    for (int i = 0; i < n; i++) {
        soma += t[i].nota;              // acumula todas as notas
        if (t[i].nota >= 7.0f) {
            printf("  %s (%.1f)\n", t[i].nome, t[i].nota);
            aprovados++;
        }
    }
    printf("Total: %d de %d\n", aprovados, n);
    printf("Media da turma: %.2f\n", soma / n);
}

#include <string.h>

int buscar(const Aluno t[], int n, const char *nome) {
    for (int i = 0; i < n; i++) {
        if (strcmp(t[i].nome, nome) == 0) {   // 0 significa "iguais"
            return i;                         // achou: para na hora
        }
    }
    return -1;                                // percorreu tudo e não achou
}

// Uso:
int i = buscar(turma, 3, "Bruno");
if (i != -1) {
    turma[i].nota = 7.5f;
} else {
    printf("Aluno nao encontrado.\n");
}

typedef struct { int dia, mes, ano; } Data;
typedef struct { char nome[50]; Data nascimento; } Pessoa;

Pessoa pessoas[4] = {
    {"Ana",   {10,  3, 2004}},
    {"Bruno", {25, 12, 2003}},
    {"Carla", { 2,  7, 2003}},
    {"Davi",  { 2,  7, 2003}}
};

int data_antes(Data a, Data b) {
    if (a.ano != b.ano) return a.ano < b.ano;   // o ano decide
    if (a.mes != b.mes) return a.mes < b.mes;   // mesmo ano: o mês decide
    return a.dia < b.dia;                       // mesmo mês: o dia decide
}

int mais_velho(const Pessoa p[], int n) {      // exige n >= 1
    int idx = 0;
    for (int i = 1; i < n; i++) {
        if (data_antes(p[i].nascimento, p[idx].nascimento)) {
            idx = i;                            // nasceu antes: é mais velho
        }
    }
    return idx;
}