C++ moderno y alternativas en C

Programación orientada a objetos (POO)

C++ ofrece clases y funciones virtuales; C modela relaciones similares con structs y punteros a función.

¿Qué es la programación orientada a objetos en C++?

La POO organiza programas en torno a objetos con estado, invariantes y comportamiento. C++ aporta clases, control de acceso, herencia y despacho virtual; C los implementa explícitamente.

Los cuatro principios fundamentales

La encapsulación protege invariantes controlando el estado interno.
La abstracción ofrece una interfaz pública pequeña.
La herencia especializa un contrato base válido.
El polimorfismo selecciona el comportamiento concreto mediante llamadas virtuales.

Cómo lo expresan C y C++

C combina structs y punteros a función; las convenciones y la API mantienen invariantes y propiedad.

C++

C++ usa estado privado, herencia y override verificados por el compilador.

Consejo: Usa destructor virtual en bases polimórficas, evita punteros crudos propietarios y prefiere composición.

Ejemplos de código C y C++

Ejecutar →

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;
}

Resultado esperado

Ada: 150.00
Lin: 210.00

C++

Ejecutar →

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';
    }
}

Resultado esperado

Ada: 150.00
Lin: 210.00

Comparación entre C y C++

C guarda estado y comportamiento en un struct. C++ mantiene el saldo privado, hereda una interfaz y sobrescribe una función virtual. En ambos casos, el cliente no comprueba el tipo concreto.

C usa prefijos, callbacks, macros y contextos explícitos.

C++

El lenguaje ofrece abstracciones con scope, type-safe y de bajo coste.

Ejercicios prácticos

Ejecuta ambas versiones y modifícalas para observar sus garantías.

Escribe primero el mecanismo en C.
Sustituye cleanup manual por RAII.
Mide allocations y dispatch virtual.