Implementació de classes

Per què?

Fins ara has fet servir classes des de fora: saps què fa cada mètode i ja està. Ara et toca l’altra cara: escriure la classe. Tens una especificació (la interfície) i has de decidir com guardar les dades i com fer que cada mètode compleixi el que promet.

Ho farem amb la classe Fraccio del capítol anterior.

Les fases

1. Triar la representació: quins atributs tindrà cada objecte. Per a la Fraccio, dos enters, _num i _den.
2. Escriure l’invariant de la representació: quines propietats compliran sempre aquests atributs (ara ho veuràs).
3. Implementar cada mètode, públic i privat, aprofitant l’invariant i mantenint-lo.

Dos fitxers

Una classe es reparteix en dos fitxers:

• Fraccio.hh: la declaració de la classe. La part public amb la capçalera i l’especificació de cada operació; la part private amb els atributs i les capçaleres de les operacions privades.
• Fraccio.cc: el codi de tots els mètodes, públics i privats.

L’ideal seria que els atributs no sortissin al .hh, perquè formen part de la implementació. Però C++ els hi demana: per crear un objecte, el compilador ha de saber quant ocupa. Com que són private, ningú de fora no els pot fer servir igualment.

El fitxer .hh

#ifndef FRACCIO_HH
#define FRACCIO_HH

class Fraccio {
public:
    // Pre: cert. Post: la fracció 0/1.
    Fraccio();

    // Pre: den != 0. Post: la fracció num/den.
    Fraccio(int num, int den);

    // Pre: cert. Post: el paràmetre implícit val el que valia més f.
    void suma(const Fraccio& f);

    // ... (la resta de mètodes públics)

private:
    int _num, _den;
    // Invariant de la representació: _den > 0 i mcd(_num, _den) = 1.

    // Pre: _den != 0. Post: _num/_den és la mateixa fracció i compleix l'invariant.
    void simplifica();
};

#endif

Les tres línies de #ifndef, #define i #endif són una guarda d’inclusió. Si un programa inclou Fraccio.hh dues vegades (per exemple, directament i a través d’un altre .hh), sense guarda el compilador veuria la classe definida dues vegades i donaria error. Amb la guarda, la segona vegada FRACCIO_HH ja està definit i se salta tot el fitxer. Tot .hh ha de portar guarda.

El fitxer .cc

#include "Fraccio.hh"

Fraccio::Fraccio() {
    _num = 0;
    _den = 1;
}

Fraccio::Fraccio(int num, int den) {
    _num = num;
    _den = den;
    simplifica();
}

void Fraccio::suma(const Fraccio& f) {
    _num = _num * f._den + f._num * _den;
    _den = _den * f._den;
    simplifica();
}

int Fraccio::numerador() const {
    return _num;
}

bool Fraccio::es_igual(const Fraccio& f) const {
    return _num == f._num and _den == f._den;
}

• Cada mètode porta davant Fraccio::, que diu de quina classe és. Sense això, seria una funció normal, sense paràmetre implícit.
• Dins d’un mètode, _num és l’atribut del paràmetre implícit, i f._num és l’atribut de l’objecte f. Un mètode de Fraccio pot tocar els atributs privats de qualsevol Fraccio, no només del paràmetre implícit: el private protegeix la classe dels de fora, no els objectes els uns dels altres.
• El const de les consultores s’ha de repetir al .cc. Si no hi és, el compilador creu que és un mètode diferent.

L’invariant de la representació

Amb dos enters es poden representar coses que no són fraccions vàlides (_den = 0) i també la mateixa fracció de moltes maneres ($1/2$, $2/4$, $-3/-6$…). Per evitar-ho, decidim que els atributs compliran sempre una propietat:

L’invariant és un compromís en dues direccions:

• Cada constructora l’ha d’establir, i cada modificadora l’ha de mantenir. Per això Fraccio(num, den), suma, multiplica i inverteix acaben cridant simplifica().
• Cada mètode el pot suposar en començar. Per això es_igual és tan curt: si totes dues fraccions estan simplificades i amb el denominador positiu, són iguals si i només si tenen els mateixos atributs. Sense l’invariant, hauria de comparar $_num \cdot f._den = f._num \cdot _den$.

L’invariant s’escriu com a comentari al .hh, al costat dels atributs. És per a qui implementa la classe, no per a qui la fa servir.

Operacions privades

simplifica() és a la part private: no és una operació del TAD, sinó una eina que fan servir els altres mètodes. Les operacions privades:

• eviten repetir codi (aquí, el mateix codi de simplificar a quatre mètodes);
• poden treballar amb objectes que temporalment no compleixen l’invariant (abans de simplificar, la fracció no el compleix). Per això no han de ser públiques: des de fora, un objecte sempre ha de complir-lo.

void Fraccio::simplifica() {
    if (_den < 0) {  // el signe, al numerador
        _num = -_num;
        _den = -_den;
    }
    int d = mcd(_num, _den);
    _num /= d;
    _den /= d;
}

Operadors

C++ et deixa definir què volen dir ==, <, <<… amb els teus tipus. Així pots escriure if (a == b) en lloc de if (a.es_igual(b)), o cout << f.

// Dins de la classe: un mètode, com qualsevol altre.
bool operator==(const Fraccio& f) const;

// Fora de la classe: l'objecte de l'esquerra és un ostream, no una Fraccio.
// Pre: cert. Post: escriu f a os en format num/den (o només num si den = 1).
ostream& operator<<(ostream& os, const Fraccio& f) {
    os << f.numerador();
    if (f.denominador() != 1) os << '/' << f.denominador();
    return os;
}

L’operator<< retorna el mateix ostream perquè es puguin encadenar: cout << a << ' ' << b. No és imprescindible definir operadors, però el codi que fa servir la classe queda més clar.

L’operator<< és una funció normal: al .hh (fora de la classe) hi poses només la capçalera, ostream& operator<<(ostream& os, const Fraccio& f);, i el codi va al .cc. Tots dos fitxers necessiten #include <iostream>.

Ampliar un TAD

Tens la Fraccio feta i provada, i un altre programa necessita una operació nova: elevar una fracció a una potència. Hi ha dues maneres de fer-ho.

Solució 1: modificar la classe. Afegeixes void eleva(int n); a la interfície i l’implementes a Fraccio.cc, amb accés directe a _num i _den.

Solució 2: una operació de fora. Fas un mòdul nou, per exemple OperacionsFraccio, amb funcions que només fan servir la interfície pública:

// Pre: n >= 0. Post: retorna f elevada a n.
Fraccio potencia(const Fraccio& f, int n) {
    Fraccio r(1, 1);
    for (int i = 0; i < n; ++i) r.multiplica(f);
    return r;
}

En el diagrama modular, la solució 2 afegeix un mòdul nou que fa servir Fraccio, i els programes que necessiten la potència fan servir aquest mòdul nou.

Compilar diversos fitxers

Cada .cc es compila per separat en un fitxer objecte (.o), i després s’enllacen tots els .o en un executable:

g++ -c Fraccio.cc        # Fraccio.cc → Fraccio.o
g++ -c main.cc           # main.cc → main.o
g++ -o programa.exe main.o Fraccio.o   # enllaça

Si després canvies només main.cc, n’hi ha prou de recompilar main.o i tornar a enllaçar. En un programa amb 50 fitxers, això estalvia molt temps. Els .hh no es compilen mai sols: s’inclouen dins dels .cc.

Fer-ho a mà és pesat. Un Makefile diu de quins fitxers depèn cada .o i com es fa; l’ordre make només recompila el que ha canviat (ho tens explicat amb calma al capítol Makefile). Aquest és el de la botiga del primer capítol:

OPCIONS = -std=c++17 -Wall -Wextra

all: botiga.exe

botiga.exe: main.o Producte.o Cistella.o
	g++ -o botiga.exe main.o Producte.o Cistella.o

main.o: main.cc Producte.hh Cistella.hh
	g++ $(OPCIONS) -c main.cc

Cistella.o: Cistella.cc Cistella.hh Producte.hh
	g++ $(OPCIONS) -c Cistella.cc

Producte.o: Producte.cc Producte.hh
	g++ $(OPCIONS) -c Producte.cc

clean:
	rm -f *.o botiga.exe

Cada regla té la forma objectiu: dependències, i a sota l’ordre per fer-lo, que ha de començar amb un tabulador (no amb espais). Fixa’t que Cistella.o depèn de Producte.hh: si canvies la interfície de Producte, Cistella s’ha de recompilar. make fa el primer objectiu (all) i make clean esborra els fitxers generats.

Errors habituals

Exercicis

#include "Fraccio.hh"

int Fraccio::denominador() {
    return _den;
}

void multiplica(const Fraccio& f) {
    _num *= f._num;
    _den *= f._den;
    simplifica();
}

void Fraccio::inverteix() {
    int aux = _num;
    _num = _den;
    _den = aux;
}

// Pre: minuts >= 0. Post: el rellotge marca aquests minuts més.
void Rellotge::avanca(int minuts) {
    _minuts = _minuts + minuts;
}

void Rellotge::avanca(int minuts) {
    _minuts = (_minuts + minuts) % 1440;
}

class Interval {
public:
    Interval(int x, int y);   // Post: l'interval del més petit de x i y al més gran.
    int inici() const;        // Post: l'extrem esquerre.
    int fi() const;           // Post: l'extrem dret.
    int longitud() const;     // Post: quants enters conté.
    bool conte(int x) const;  // Post: si x és dins de l'interval.
    bool es_solapa(const Interval& i) const;  // Post: si tenen algun enter en comú.
    void uneix(const Interval& i);  // Post: el p.i. és el menor interval que conté
                                    //       el p.i. original i i.
};

class Interval {
    ...
private:
    int _a, _b;
    // Invariant de la representació: _a <= _b.
};

Interval::Interval(int x, int y) {
    if (x <= y) {
        _a = x;
        _b = y;
    }
    else {
        _a = y;
        _b = x;
    }
}

int Interval::inici() const {
    return _a;
}

int Interval::fi() const {
    return _b;
}

int Interval::longitud() const {
    return _b - _a + 1;  // gràcies a l'invariant, mai no és negativa
}

bool Interval::conte(int x) const {
    return _a <= x and x <= _b;
}

bool Interval::es_solapa(const Interval& i) const {
    return _a <= i._b and i._a <= _b;
}

void Interval::uneix(const Interval& i) {
    if (i._a < _a) _a = i._a;
    if (i._b > _b) _b = i._b;
}

// Pre: cert. Post: retorna si a és més petita que b.
bool mes_petita(const Fraccio& a, const Fraccio& b) {
    // Els denominadors són positius: p/q < r/s si i només si p*s < r*q.
    return a.numerador() * b.denominador() < b.numerador() * a.denominador();
}

OPCIONS = -std=c++17 -Wall -Wextra

all: programa.exe

programa.exe: main.o Jugador.o Partida.o
	g++ -o programa.exe main.o Jugador.o Partida.o

main.o: main.cc Jugador.hh Partida.hh
	g++ $(OPCIONS) -c main.cc

Partida.o: Partida.cc Partida.hh Jugador.hh
	g++ $(OPCIONS) -c Partida.cc

Jugador.o: Jugador.cc Jugador.hh
	g++ $(OPCIONS) -c Jugador.cc

clean:
	rm -f *.o programa.exe