4. hét: C++11 osztályhierarchiák

Definíció kérdése. Biológiából igen, de OOP-ben általában nem. Ugyanis ha a Bird osztálynak van egy fly() tagfüggvénye, akkor az Ostrich osztálynak is lesz fly() tagfüggvénye. Ha minden madár tud repülni, és a strucc egy madár, akkor a strucc is tud repülni. Ezért OOP-ben az Ostrich osztály nem szabad a madárból származtassa magát, különben megsérti azt a szerződést, amelyet a Bird osztály a használóival kötött (ti. hogy meg lehet hívni az objektumon a fly() tagfüggvényt, és az értelmes dolgot fog csinálni).

Mint a struccos példa: matekból igen, OOP-ből nem. Ha az ellipszis ígér olyat, amit a kör nem tud betartani (például hogy van set_size(width, height) tagfüggvénye), akkor a kör nem lehet ellipszis.

Örökölné a sugarát lekérdező függvényt is. Ha pl. ilyen van, akkor semmiképp.

Ellipse e1{2, 3};
std::cout << e1.get_radius();   // ?!

Amikor a C++ egy sornál választhat, hogy egy objektum definíciójáról vagy egy függvény deklarációjáról van szó, mindig az utóbbit részesíti előnyben. A c2 ezért egy függvény lett, amely két paraméterű, és Complex visszatérési értékű. Az első paraméter típusa Complex, neve pedig c1. (Igen, és a zárójelet, mivel nem módosítja a jelentést, feleslegesnek ítéli a fordító. Próbáld ki: int (main)(int (argc), char **(argv)){}!) A második, névtelen paraméternél egy függvény típust adunk meg; a függvénynek nincs paramétere, a visszatérési típusa Complex. A tömbökhöz hasonlóan a paraméterként átadott függvényeket pointerként kezeli a fordító. Ezek alapján a c2-es sor ezzel egyenértékű:

Complex c2(Complex param1, Complex (*param2)());

Így már jobban látszik, hogy ez egy függvény.

A fenti példákban a szabatosság kedvéért vannak az osztályon belül megírva a függvények. Ezt meg szabad tenni a virtuális függvényeknél is. Mivel a fordító tudja, hogy virtuális függvényről van szó, tudja azt is, hogy a virtuális függvénytábla pointere miatt muszáj nem inline változatot is készítenie belőle. A hívás általában a függvénytáblán keresztül történik, azonban lehetséges olyan helyzet, ahol már fordítási időben ki lehet választani a függvényt, és így akár kódbeillesztéssel is megvalósítható a hívás:

Constant c1{5.1};
c1.print(std::cout);

Itt például pontosan ismert a c1 objektum típusa.

Semmi.

Tartalmaz egy pointert, amelyik a virtuális függvénytáblájára mutat. Úgyhogy nem üres, csak nincsenek a felhasználó által is látható adattagjai.

Van, a fordító írt neki. Egy olyat, ami meghívja azt adattagok destruktorait (bár most nincsenek adattagok), utána pedig meghívja az ős destruktorát.

Nem. Az objektumokban nincsenek virtuális függvényekre mutató pointerek, hanem csak egy virtuális függvénytáblára mutató pointer van (amely lényegében egy pointereket tartalmazó struktúra). Így ha már volt egy virtuális függvény, további virtuális függvények hozzáadásának nincs semmilyen plusz költsége.

A print() metódus és a globális operator<< (amely szinte része az osztálynak) már most is ilyen. A print() lehetne privát, a kiíró operátor pedig friend, és pl. minden kiírt kifejezés elé odaírná, hogy f(x)=. A leszármazottak pedig ebből tudnák, hogy az nem az ő dolguk.

Az evaluate() is lehetne privát, mondjuk do_evaluate() néven. A publikus, nem virtuális evaluate() pedig ellenőrizné, hogy nem hibás-e a paraméterként kapott double x, mielőtt ténylegesen belekezd a kiértékelésbe. Például hogy nem inf vagy nan értékű-e.

Mint az összeg és a szorzat, csak - és / operátorokkal.

A függvény osztály hasonló a kétoperandusúhoz. Pl. sin(2x): a kiértékeléskor ki kell értékelni a belül tárolt kifejezést (2x), utána pedig alkalmazni kell a függvényt (sin). A kiírásnál pedig ki kell írni a függvény nevét, zárójel, belső kifejezés, zárójel.

Amíg még létre sem jött az objektum, nincs virtuális függvénytábla. A virtuális konstruktor tervezési mintát így csak meglévő objektumokkal tudjuk használni.

#include <cstdio>


void draw(Expression *e, char const *filename, char const *color) {
    FILE *fp = fopen(filename, "wt");
    double w = 320, h = 240;
    double zoom = 20;
    fprintf(fp, R"(<svg width="%f" height="%f" xmlns="http://www.w3.org/2000/svg">)", w, h);
    double dx = 0.1;
    for (double x = -5.0; x <= +5.0; x += dx) {
        double x1 = x;
        double y1 = e->evaluate(x1);
        double x2 = x + dx;
        double y2 = e->evaluate(x2);
        
        x1 = x1 * zoom + w/2;
        y1 = y1 * -zoom + h/2;
        x2 = x2 * zoom + w/2;
        y2 = y2 * -zoom + h/2;
        fprintf(fp, R"(<line x1="%f" y1="%f" x2="%f" y2="%f" stroke="%s" />)", x1, y1, x2, y2, color);
    }
    fprintf(fp, R"(</svg>)");
}

Egy lehetséges megoldás a következő.

class Expression {
  public:
    /* ez írja ki egy csomópont adatait; a this értéke bekerül a csomópont nevébe.
     * a leszármazottak get_label() tagfüggvénye a feliratot fogja megadni. */
    virtual void dot(std::ostream &os) const {
        os << "node_" << this << " [label=\"" << get_label() << "\"];\n";
    }
  private:    
    virtual std::string get_label() const = 0;
};

/* így néznek ki a get_label() függvények */
class Constant : public Expression {
    std::string get_label() const {
        std::ostringstream os;
        os << c_;
        return os.str();
    }
};

class Variable: public Expression {
    std::string get_label() const {
        return "x";
    }
};

/* a kétoperandusú műveletek a csomópont adatai mellett kiírják
 * az éleket is, és meghívják a gyerekek kiíró függvényét is. */
class TwoOperand : public Expression {
    /* write to dot file */
    virtual void dot(std::ostream &os) const final {
        Expression::dot(os);
        os << "node_" << this << " -> " << "node_" << lhs_ << ";\n";
        os << "node_" << this << " -> " << "node_" << rhs_ << ";\n";
        lhs_->dot(os);
        rhs_->dot(os);
    }

    /* az eddigi kiírás miatt már úgyis van ez a függvényünk,
     * ami megadja az operátort. az jó lesz feliratnak. */
    std::string get_label() const final {
        char str[] = { get_operator(), '\0' };
        return str;
    }
};