El lenguaje C++

01Qué agrega C++ sobre C

C++ es, casi por completo, un superconjunto de C: un programa en C compila en C++. Lo que suma es una forma distinta de organizar programas grandes.

02Clases y objetos

Una clase es un molde: describe qué datos tiene una cosa y qué se puede hacer con ella. Un objeto es un ejemplar concreto creado a partir de ese molde.

class Led {
  private:                       // nadie de afuera puede tocar esto
    uint8_t pin;
    bool    encendido;

  public:                        // la interfaz visible
    Led(uint8_t p);                 // constructor
    void on();
    void off();
    void toggle();
    bool estado() const;          // const: no modifica el objeto
};

// --- implementación ---
Led::Led(uint8_t p) : pin(p), encendido(false) {
    pinMode(pin, OUTPUT);
    digitalWrite(pin, LOW);
}
void Led::on()     { digitalWrite(pin, HIGH); encendido = true; }
void Led::off()    { digitalWrite(pin, LOW);  encendido = false; }
void Led::toggle() { encendido ? off() : on(); }
bool Led::estado() const { return encendido; }

// --- uso ---
Led rojo(13);       // se crean dos objetos independientes
Led verde(12);      // cada uno con su propio pin y su propio estado

rojo.on();
verde.toggle();

03Constructores y destructores

class PuertoSerie {
    int fd;
  public:
    PuertoSerie(uint32_t baudios) {
        fd = abrir_uart(baudios);       // toma el recurso
    }
    ~PuertoSerie() {
        cerrar_uart(fd);               // lo devuelve, pase lo que pase
    }
    void enviar(const char *s);
};

void tarea() {
    PuertoSerie p(9600);   // constructor: abre
    p.enviar("hola");
    if (error) return;      // aun saliendo por acá...
    ...
}                            // ...el destructor cierra el puerto

04Sobrecarga

En C++ pueden coexistir varias funciones con el mismo nombre si difieren en la cantidad o el tipo de sus parámetros. El compilador elige la correcta según cómo se la llame.

void mostrar(int v);
void mostrar(float v);
void mostrar(const char *s);
void mostrar(int v, uint8_t base);

mostrar(42);           // llama a la primera
mostrar(3.14f);        // a la segunda
mostrar("listo");      // a la tercera
mostrar(255, 16);      // a la cuarta: en hexadecimal

En C harían falta cuatro nombres distintos (mostrar_int, mostrar_float…). Es exactamente lo que hace Serial.print() de Arduino, que acepta enteros, decimales y cadenas: son varias funciones sobrecargadas.

Sobrecarga de operadores

class Medicion {
    int16_t mV;
  public:
    Medicion(int16_t v) : mV(v) {}
    Medicion operator+(const Medicion &o) const {
        return Medicion(mV + o.mV);
    }
    bool operator>(const Medicion &o) const { return mV > o.mV; }
};

Medicion a(1200), b(340);
Medicion c = a + b;      // se lee como matemática
if (a > b) { ... }

05Herencia

Una clase puede derivar de otra: hereda sus datos y sus métodos, y agrega o modifica lo que necesite. Es la forma de expresar una relación «es un».

class Sensor {                     // clase base
  protected:                        // visible para las derivadas
    uint8_t pin;
  public:
    Sensor(uint8_t p) : pin(p) {}
    virtual float leer() = 0;        // = 0 : virtual PURA
    virtual ~Sensor() {}              // destructor virtual: obligatorio
};

class SensorTemp : public Sensor {   // deriva de Sensor
  public:
    SensorTemp(uint8_t p) : Sensor(p) {}
    float leer() override {        // LM35: 10 mV por grado
        return analogRead(pin) * 500.0f / 1024.0f;
    }
};

06Polimorfismo e interfaces

Es la consecuencia poderosa de la herencia: se puede escribir código que trabaje con la clase base y funcione correctamente con cualquier derivada, incluso con las que todavía no existen.

// Esta función no sabe ni le importa qué sensores hay
void registrar(Sensor *lista[], uint8_t n) {
    for (uint8_t i = 0; i < n; i++) {
        float v = lista[i]->leer();   // llama al leer() CORRECTO
        guardar(i, v);
    }
}

SensorTemp t(0);
SensorLuz  l(1);
SensorHum  h(2);
Sensor *todos[] = { &t, &l, &h };

registrar(todos, 3);   // cada uno se lee como corresponde

Interfaces: clases abstractas puras

Una clase cuyos métodos son todos virtuales puros (= 0) no se puede instanciar: define únicamente un contrato. Es el mecanismo con el que se declara «lo que un driver tiene que saber hacer», sin decir nada sobre cómo.

class IDisplay {                 // interfaz: sólo el contrato
  public:
    virtual void limpiar() = 0;
    virtual void escribir(uint8_t f, uint8_t c, const char *t) = 0;
    virtual ~IDisplay() {}
};

class LCD1602  : public IDisplay { /* por 4 bits paralelo */ };
class OLED_I2C : public IDisplay { /* por bus I2C */ };
class DisplayFalso : public IDisplay { /* imprime en consola: para probar */ };

// El menú funciona con cualquiera de los tres, sin cambiar una línea
void menu(IDisplay &d) {
    d.limpiar();
    d.escribir(0, 0, "Temperatura");
}

07Excepciones

Permiten separar el manejo de errores del flujo normal del programa: en vez de que cada función devuelva un código de error que hay que verificar, se lanza una excepción que se captura donde corresponda.

try {
    float t = sensor.leer();      // puede lanzar
    procesar(t);
}
catch (const SensorDesconectado &e) {
    alarma("sensor fuera de linea");
}
catch (...) {                     // cualquier otra
    reiniciar();
}

08C++ en microcontroladores

09En el laboratorio

10Errores frecuentes