Dziedziczenie wielokrotne, inicjalizacja

Question

Witam, mam tutaj pewien projekt z zadania z książki Stephena Praty:

Plik .h:

#include <string>
using namespace std;
class fink;
class manager;
class abstr_emp
{
private:
	string fname;
	string lname;
	string job;
public:
	abstr_emp();
	abstr_emp(const manager&m1);
	abstr_emp(const fink&f1);
	abstr_emp(const string &, const string &, const string &);
	virtual void ShowAll() const;
	virtual void SetAll();
	friend ostream & operator<<(ostream &, const abstr_emp&);
	virtual ~abstr_emp() = 0;
};
class employee : public abstr_emp
{
public:
	employee();
	employee(const string & fn, const string &ln, const string & j);
	virtual void ShowAll() const;
	virtual void SetAll();
};
class manager :virtual public abstr_emp
{
private:
	int inchargeof;
protected:
	int InChargeOf() const { return inchargeof; }
	int & InChargeOf() { return inchargeof; }
public:
	manager();
	manager(const string & fn, const string & ln, const string & j, int ico = 0);
	manager(const abstr_emp & e, int ico);
	manager(const fink&m, int ico);
	void ShowIco() const { cout << inchargeof << endl; }

	virtual void ShowAll() const;
	virtual void SetAll();
};
class fink : virtual public abstr_emp
{
private:
	string reportsto;
protected:
	const string ReportsTo() const { return reportsto; }
	string & ReportsTo() { return reportsto; }
public:
	fink();
	fink(const string & fn, const string & ln, const string & j, const string & rpo);
	fink(const abstr_emp & e, const string &rpo);
	fink(const manager & e, string & rpo);
	void ShowRpo() const { cout << reportsto << endl; }
	virtual void ShowAll() const;
	virtual void SetAll();
};
class highfink : public manager, public fink
{
public:
	highfink();
	highfink(const string & fn, const string & ln, const string & j, const string & rpo, int ico);
	highfink(const abstr_emp & e, const string & rpo, int ico);
	highfink(const fink & f, int ico);
	highfink(const manager & m, const string & rpo);
	highfink(const highfink&h);
	virtual void ShowAll() const;
	virtual void SetAll() {};
};

oraz plik .cpp :

#include "stdafx.h"
#include <iostream>
#include <string>
#include "Nagłówek.h"

using namespace std;

abstr_emp::abstr_emp(const string & fn, const string & ln, const string & j) {
	fname = fn;
	lname = ln;
	job = j;
}

abstr_emp::abstr_emp() {
	fname = "unknown";
	lname = "unknown";
	job = "unknown";
}

abstr_emp::abstr_emp(const manager&m1) {
	fname = m1.fname;
	lname = m1.lname;
	job = m1.job;
}

abstr_emp::abstr_emp(const fink&f1) {
	fname = f1.fname;
	lname = f1.lname;
	job = f1.job;
}

ostream & operator<<(ostream & s, const abstr_emp & e) {
	s << e.fname << " " << e.lname << " " << e.job << endl;
	return s;
}
void abstr_emp::ShowAll() const {
	cout << fname << " " << lname << " " << job << endl;
}
void abstr_emp::SetAll() {
	cin >> fname >> lname >> job;
}
abstr_emp::~abstr_emp() {}

employee::employee(const string & fn, const string &ln, const string & j) :abstr_emp(fn, ln, j) {}
void employee::ShowAll() const {
	abstr_emp::ShowAll();
}
void employee::SetAll() {
	abstr_emp::SetAll();
}

manager::manager(const string & fn, const string & ln, const string & j, int ico) : abstr_emp(fn, ln, j), inchargeof(ico) {}
manager::manager(const abstr_emp & e, int ico) : abstr_emp(e), inchargeof(ico) {}
manager::manager(const fink&m, int ico):abstr_emp(m), inchargeof(ico){}
void manager::ShowAll() const {
	abstr_emp::ShowAll();
	manager::ShowIco();
}
void manager::SetAll() {
	int temp;
	abstr_emp::SetAll();
	cin >> temp;
	InChargeOf() = temp;
}

fink::fink(const string & fn, const string & ln, const string & j, const string & rpo) :abstr_emp(fn, ln, j), reportsto(rpo) {}
fink::fink(const abstr_emp & e, const string &rpo) : abstr_emp(e), reportsto(rpo) {}
fink::fink(const manager & e, string & rpo):abstr_emp(e), reportsto(rpo) {}
void fink::ShowAll() const {
	abstr_emp::ShowAll();
	fink::ShowRpo();
}
void fink::SetAll() {
	abstr_emp::SetAll();
	string temp;
	cin >> temp;
	ReportsTo() = temp;
}

highfink::highfink(const string & fn, const string & ln, const string & j, const string & rpo, int ico) : abstr_emp(fn, ln, j), manager(fn, ln, j, ico), fink(fn, ln, j, rpo) {}
highfink::highfink(const abstr_emp & e, const string & rpo, int ico) : abstr_emp(e), manager(e, ico), fink(e, rpo) {}
highfink::highfink(const fink & f, int ico):fink(f),manager(f,ico){}
highfink::highfink(const manager & m, const string & rpo):fink(m,rpo),manager(m){}
void highfink::ShowAll() const {
	abstr_emp::ShowAll();	
    fink::ShowRpo();
    manager::ShowIco();
}

Wcześniej umieściłem tutaj pytanie dotyczącego tego samego projektu, odnośnie konstruktorów. Problem został rozwiązany ale pojawiła się nowa niejasność. Po skompilowaniu tworzę obiekt klasy manager, załóżmy manager m1("John","Smith","doctor",5). Metoda ShowAll() pokazuje poprawnie wszystkie informacje. Następnie chciałbym wykorzystać obiekt tej klasy w konstruktorze highfink. A więc: highfink(m1,"rep"). I problem pojawia się podczas wywołania metody ShowAll(), ponieważ wyświetla ona zamiast "John Smith doctor rep 5", to "unknown unknown unknown rep 5", więc dla obiektu klasy bazowej są wyświetlane wartości domyślne. Proszę o pomoc oraz doradzenie jakie zmiany powinienem poczynić, aby metoda ShowAll klasy highfink działała poprawnie.

Comments

Pokaż kod w którym faktycznie korzystasz z instancji tych klas :)

---

już problem rozwiązany ;)

Answer 1

Ok już wiem. Za konstrukcje obiektów dziedziczonych wirtualnie odpowiada klasa najbardziej pochodna. Więc:

highfink::highfink(const manager & m, const string & rpo) : fink(m, rpo), manager(m) {}

nie ma jawnego wywołania konstruktora abstr_emp więc wywoływany jest konstruktor domyślny, który ustawia "unknown". 

Przy okazji zauważyłem też, że:

fink::fink(const abstr_emp & e, const string &rpo) : abstr_emp(e), reportsto(rpo) {}
fink::fink(const manager & e, string & rpo) : abstr_emp(e), reportsto(rpo) {}

jak przesyłasz const string& to nigdy nie zostanie użyty drugi konstruktor.

Comments

rzeczywiście, to rozwiązało problem, dzięki wielkie. byłem przekonany, że skoro klasa abstr_emp jest czysto wirtualna to nie muszę wywoływać listą jej konstruktora, a jednak :)