Tipos Abstratos de Dados (TAD)

Um tipo primitivo representa uma categoria básica de valor oferecida diretamente pela linguagem. Ele define quais valores cabem ali e quais operações básicas fazem sentido. Em C++, exemplos fundamentais são inteiros, números de ponto flutuante, caracteres e booleanos.

Criar uma variável nova para cada aluno funciona somente enquanto a quantidade é pequena e fixa. Os nomes das variáveis não permitem que um laço percorra automaticamente todos os alunos.

std::string nomeDoAluno1 = "Ana";
std::string nomeDoAluno2 = "Bia";
std::string nomeDoAluno3 = "Caio";

// E quando chegarem mais 100 alunos?

std::array<std::string, 3> nomes{
    "Ana", "Bia", "Caio"
};

for (const auto& nome : nomes) { ... }

O array resolveu a repetição de nomes, mas um aluno não possui somente nome. Se criarmos uma variável separada para cada campo e para cada pessoa, voltamos ao mesmo problema.

struct Aluno {
    std::string nome;
    int idade;
    double media;
};

class Aluno {
    std::string nome;
    int idade;

public:
    void apresentar() const;
    bool maiorDeIdade() const;
};

Depois de modelar um aluno, surge uma nova pergunta: como organizar muitos objetos Aluno? A resposta depende das operações e relações do problema.

Ao dirigir, você usa volante, acelerador e freio sem precisar conhecer o motor. Carros diferentes preservam esse conjunto de operações, mesmo usando mecanismos internos diferentes. Um TAD aplica essa mesma separação ao software.

Uma assinatura informa nome, entradas e saída. O contrato completa a informação dizendo o que precisa ser verdade antes da chamada e o que será garantido depois dela.

LIFO significa last in, first out: o último valor que entra é o primeiro que sai. Use os controles e observe que a regra não depende de saber como a pilha foi armazenada.

A classe abstrata abaixo registra as operações públicas. Ela não decide onde os elementos serão guardados. Essa escolha pertence às classes concretas.

// Contrato do TAD Pilha
template <typename T>
class Pilha {
public:
    virtual ~Pilha() = default;

    virtual void empilhar(T valor) = 0;
    virtual T desempilhar() = 0;
    virtual const T& topo() const = 0;
    virtual bool vazia() const = 0;
};

template <typename T>
class PilhaVetor : public Pilha<T> {
    std::vector<T> dados;

public:
    void empilhar(T valor) override {
        dados.push_back(valor);
    }

    T desempilhar() override {
        T valor = dados.back();
        dados.pop_back();
        return valor;
    }
    // topo() e vazia() seguem o contrato.
};

template <typename T>
class PilhaLista : public Pilha<T> {
    struct No {
        T valor;
        std::unique_ptr<No> proximo;
    };
    std::unique_ptr<No> topoDaPilha;

public:
    void empilhar(T valor) override {
        topoDaPilha = std::make_unique<No>(
            No{valor, std::move(topoDaPilha)}
        );
    }
    // As mesmas operações públicas.
};

Uma lista responde bem “quais elementos estão na sequência?”. Um grafo foi feito para perguntas como “quem está conectado?”, “qual caminho liga duas pessoas?” e “quais relações existem entre estas entidades?”.