C++ moderno e alternativas em C

Programação orientada a objetos (POO)

C++ oferece classes e funções virtuais; C modela relações semelhantes com structs e ponteiros de função.

O que é programação orientada a objetos em C++?

A POO organiza programas em objetos com estado, invariantes e comportamento. C++ fornece classes, controle de acesso, herança e despacho virtual; C os implementa explicitamente.

Os quatro princípios fundamentais

O encapsulamento protege invariantes controlando o estado interno.
A abstração apresenta uma interface pública pequena.
A herança especializa um contrato base válido.
O polimorfismo seleciona o comportamento concreto por chamadas virtuais.

Como C e C++ expressam o projeto

C combina structs e ponteiros de função; convenções e API mantêm invariantes e propriedade.

C++

C++ usa estado privado, herança e override verificados pelo compilador.

Dica: Use destrutor virtual em bases polimórficas, evite raw pointers proprietários e prefira composição.

Exemplos de código C e C++

Executar →

main.c

#include <stdio.h>

typedef struct Account Account;
typedef void (*MonthEnd)(Account *account);

struct Account {
    const char *owner;
    double balance;
    double interest_rate;
    MonthEnd month_end;
};

void standard_month_end(Account *account) {
    (void)account;
}

void savings_month_end(Account *account) {
    account->balance *= 1.0 + account->interest_rate;
}

void print_account(Account *account) {
    account->month_end(account);
    printf("%s: %.2f\n", account->owner, account->balance);
}

int main(void) {
    Account accounts[] = {
        {"Ada", 150.0, 0.0, standard_month_end},
        {"Lin", 200.0, 0.05, savings_month_end}
    };

    for (int i = 0; i < 2; ++i) {
        print_account(&accounts[i]);
    }
    return 0;
}

Saída esperada

Ada: 150.00
Lin: 210.00

C++

Executar →

main.cpp

#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
#include <vector>

class Account {
    std::string owner_;
    double balance_;

protected:
    void add_balance(double amount) { balance_ += amount; }

public:
    Account(std::string owner, double balance)
        : owner_(std::move(owner)), balance_(balance) {}

    virtual ~Account() = default;
    virtual void month_end() {}

    const std::string& owner() const { return owner_; }
    double balance() const { return balance_; }
};

class SavingsAccount final : public Account {
    double interest_rate_;

public:
    SavingsAccount(std::string owner, double balance, double rate)
        : Account(std::move(owner), balance), interest_rate_(rate) {}

    void month_end() override {
        add_balance(balance() * interest_rate_);
    }
};

int main() {
    Account standard("Ada", 150.0);
    SavingsAccount savings("Lin", 200.0, 0.05);
    std::vector<Account *> accounts{&standard, &savings};

    std::cout << std::fixed << std::setprecision(2);
    for (Account *account : accounts) {
        account->month_end();
        std::cout << account->owner() << ": "
                  << account->balance() << '\n';
    }
}

Saída esperada

Ada: 150.00
Lin: 210.00

Comparação entre C e C++

C guarda estado e comportamento em uma struct. C++ mantém o saldo privado, herda uma interface e sobrescreve uma função virtual. O cliente não testa o tipo concreto.

C usa prefixos, callbacks, macros e contextos explícitos.

C++

O idioma fornece abstrações com escopo, type-safe e de baixo custo.

Exercícios práticos

Execute as duas versões e modifique-as para observar suas garantias.

Escreva primeiro o mecanismo em C.
Substitua cleanup manual por RAII.
Meça alocações e dispatch virtual.