Cześć! Przerabiam książkę "Język C++. Szkoła programowania" Stephana Prata. Jestem na rozdziale mówiącym o dziedziczeniu, itp. Mam pytanie odnośnie konstruktora klasy pochodnej.
Jak wiadomo nie można tworzyć obiektów klasy abstrakcyjnej. W przykładzie występuje konstruktor klasy pochodnej, który jako jeden z argumentów ma referencję do obiektu klasy bazowej abstrakcyjnej.
Skoro nie mogę przekazać mu obiektu klasy abstrakcyjnej (bo taki nie może powstać) to czy mogę mu przekazać obiekt klasy pochodnej, który zawiera podobiekt klasy bazowej?
Czy taki jest sens takiego konstruktora? Oto plik nagłówkowy z interfejsem (pytanie o m.in. linijkę 59):
// workermi.h -- hierarchia klas z uzyciem dziedziczenia wielokrotnego
#ifndef WORKERMI_H_
#define WORKERMI_H_
#include <string>
class Worker // abstrakcyjna klasa bazowa
{
private:
std::string fullname;
long id;
protected:
virtual void Data() const;
virtual void Get();
public:
Worker() : fullname("brak"), id(0L) {}
Worker(const std::string & s, long n)
: fullname(s), id(n) {}
virtual ~Worker() = 0; // funkcja czysto wirtualna
virtual void Set() = 0;
virtual void Show() const = 0;
};
class Waiter : virtual public Worker
{
private:
int panache;
protected:
void Data() const;
void Get();
public:
Waiter() : Worker(), panache(0) {}
Waiter(const std::string & s, long n, int p = 0)
: Worker(s, n), panache(p) {}
Waiter(const Worker & wk, int p = 0)
: Worker(wk), panache(p) {}
void Set();
void Show() const;
};
class Singer : virtual public Worker
{
protected:
enum {inna, alt, kontralt, sporan,
bas, baryton, tenor};
enum {Vtypes = 7};
void Data() const;
void Get();
private:
static const char *pv[Vtypes]; // odpowiednik skali glosu w postaci ciagu znakow
int voice;
public:
Singer() : Worker(), voice(inna) {}
Singer(const std::string & s, long n, int v = inna)
: Worker(s, n), voice(v) {}
//////////////////////////////////////
// PYTANIE ODNOSCIE NP. TEGO FRAGMENTU
//////////////////////////////////////
Singer(const Worker & wk, int v = inna)
: Worker(wk), voice(v) {}
void Set();
void Show() const;
};
// dziedziczenie wielokrotne
class SingingWaiter : public Singer, public Waiter
{
protected:
void Data() const;
void Get();
public:
SingingWaiter() {}
SingingWaiter(const std::string & s, long n, int p = 0,
int v = inna)
: Worker(s, n), Waiter(s, n, p), Singer(s, n, v) {}
SingingWaiter(const Worker & wk, int p = 0, int v = inna)
: Worker(wk), Waiter(wk, p), Singer(wk, v) {}
SingingWaiter(const Waiter & wt, int v = inna)
: Worker(wt), Waiter(wt), Singer(wt, v) {}
SingingWaiter(const Singer & wt, int p = 0)
: Worker(wt), Waiter(wt, p), Singer(wt) {}
void Set();
void Show() const;
};
#endif // WORKERMI_H_