The C++ language

01What C++ adds to C

C++ is, almost entirely, a superset of C: a C program compiles as C++. What it adds is a different way of organizing large programs.

02Classes and objects

A class is a mold: it describes what data a thing has and what can be done with it. An object is a concrete instance created from that mold.

class Led {
  private:                       // nobody outside can touch this
    uint8_t pin;
    bool    encendido;

  public:                        // the visible interface
    Led(uint8_t p);                 // constructor
    void on();
    void off();
    void toggle();
    bool estado() const;          // const: does not modify the object
};

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

// --- usage ---
Led rojo(13);       // two independent objects are created
Led verde(12);      // each with its own pin and its own state

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

03Constructors and destructors

class PuertoSerie {
    int fd;
  public:
    PuertoSerie(uint32_t baudios) {
        fd = abrir_uart(baudios);       // takes the resource
    }
    ~PuertoSerie() {
        cerrar_uart(fd);               // gives it back, no matter what
    }
    void enviar(const char *s);
};

void tarea() {
    PuertoSerie p(9600);   // constructor: opens
    p.enviar("hello");
    if (error) return;      // even when leaving here...
    ...
}                            // ...the destructor closes the port

04Overloading

In C++ several functions can coexist with the same name if they differ in the number or the type of their parameters. The compiler picks the right one depending on how it is called.

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

mostrar(42);           // calls the first one
mostrar(3.14f);        // the second
mostrar("done");      // the third
mostrar(255, 16);      // the fourth: in hexadecimal

In C you would need four different names (mostrar_int, mostrar_float…). This is exactly what Arduino’s Serial.print() does: it accepts integers, decimals and strings, because it is really several overloaded functions.

Operator overloading

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;      // reads like math
if (a > b) { ... }

05Inheritance

A class can derive from another: it inherits its data and methods, and adds or modifies whatever it needs. It is the way to express an “is a” relationship.

class Sensor {                     // base class
  protected:                        // visible to the derived classes
    uint8_t pin;
  public:
    Sensor(uint8_t p) : pin(p) {}
    virtual float leer() = 0;        // = 0 : PURE virtual
    virtual ~Sensor() {}              // virtual destructor: mandatory
};

class SensorTemp : public Sensor {   // derives from Sensor
  public:
    SensorTemp(uint8_t p) : Sensor(p) {}
    float leer() override {        // LM35: 10 mV per degree
        return analogRead(pin) * 500.0f / 1024.0f;
    }
};

06Polymorphism and interfaces

It is the powerful consequence of inheritance: you can write code that works with the base class and works correctly with any derived class, even those that do not exist yet.

// This function neither knows nor cares which sensors there are
void registrar(Sensor *lista[], uint8_t n) {
    for (uint8_t i = 0; i < n; i++) {
        float v = lista[i]->leer();   // calls the CORRECT leer()
        guardar(i, v);
    }
}

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

registrar(todos, 3);   // each one is read the way it should be

Interfaces: pure abstract classes

A class whose methods are all pure virtual (= 0) cannot be instantiated: it defines only a contract. It is the mechanism used to declare “what a driver has to be able to do,” without saying anything about how.

class IDisplay {                 // interface: just the contract
  public:
    virtual void limpiar() = 0;
    virtual void escribir(uint8_t f, uint8_t c, const char *t) = 0;
    virtual ~IDisplay() {}
};

class LCD1602  : public IDisplay { /* 4-bit parallel */ };
class OLED_I2C : public IDisplay { /* over the I2C bus */ };
class DisplayFalso : public IDisplay { /* prints to the console: for testing */ };

// The menu works with any of the three, without changing a line
void menu(IDisplay &d) {
    d.limpiar();
    d.escribir(0, 0, "Temperature");
}

07Exceptions

They let you separate error handling from the normal flow of the program: instead of every function returning an error code that has to be checked, an exception is thrown and caught wherever appropriate.

try {
    float t = sensor.leer();      // may throw
    procesar(t);
}
catch (const SensorDesconectado &e) {
    alarma("sensor offline");
}
catch (...) {                     // any other
    reiniciar();
}

08C++ on microcontrollers

09In the lab

10Common mistakes