C++笔记-多重继承

2016-12-30

必须使用关键字来限定每一个基类,不然编译器会默认成私有派生:

1	class mylove : public string, valarray<double> //valarray为私有继承

其实你不用看这仨奇葩类的

class Worker
{
public:
    Worker() : name("NULL"),id(0L){}
    Worker(const string & s,long n) : name(s),id(n){}
    virtual ~Worker() = 0;
    virtual void Set();
    virtual void Show() const;
private:
    string name;
    long id;
};
class Waiter : public Worker
{
public:
    Waiter() : Worker(),panache(0){}
    Waiter(const string & s, long n, int p = 0) :
        Worker(s,n),panache(p){}
    Waiter(const Worker & w, int p) : Worker(w),panache(p){}
    void Set();
    void Show() const;
private:
    int panache;
};
class Singer : public Worker
{
public:
    Singer() : Worker(),voice(other){}
    Singer(const string & s, long n, int v = other) :
        Worker(s,n),voice(v){}
    Singer(const Worker & w, int v =other) : Worker(w),voice(v){}
    void Set();
    void Show() const;
protected:
    enum{other,alto,contralto,soprano,bass,baritone,tenor};
    enum{Vtypes = 7};
private:
    static char* pv[Vtypes];
    int voice;
};

Worker?

从Singer和Waiter共有派生出SingingWaiter:

1	class SingingWaiter : public Singing, public Waiter{...}

但这将出现二义性,因为Singing和Waiter都继承了一个Worker:

1 2	SingingWaiter sw; Worker* pw = sw; //二义性,鬼知道这时候用哪个worker

so..应该使用类型转换来指定对象:

1
2
3

Worker* pw = (Singing*) &sw;
Worker* pw2 = (Waiter*) &sw;
//不过下面还有更简(ma)单(fan)的虚基类可以解决该问题

虚基类

虚基类使得从多个类(他们基类相同)派生出的对象只继承一个基类对象.例如:在类声明中使用关键字virtual,可以使Worker被作用Singer和Waiter的虚基类:

1 2	class Singer : virtual public Worker{...} class Waiter : public virtual Worker{...} //这么写也行

然后 SingingWaiter可以定义为:

1	class SingingWaiter : public Singer,public Waiter{...}

现在SingingWaiter类只有一个Worker对象副本了,Singer和worker共享一个Worker对象,所以现在可以使用多态了.

新的构造函数规则

使用虚基类时,构造函数需要使用一种新的方法,这是因为C++在基类是虚的时,禁止信息通过中间自动传递给基类,编译器在这时会使用基类的默认构造函数.

//通过中间类自动传递:
class A{
    int a;
    A(int n = 0) : a(n);
}
class B :public A{
    int b;
    B(int a = 0, int bm = 0) : A(a),b(bm);
}
class C : public B{
    int c;
    C(int a = 0, int b = 0, int cm = 0) : B(a,b),c(cm);
}

使用虚基类时我们必须显示调用构造函数:

SingingWaiter(const Worker & wk,int p = 0,int v = Singer::other)
                :Worker(wk),Waiter(wk,p),Singer(wk,v){}
                //显示使用worker
                
SingingWaiter(const Worker & wk, int p = 0, int v = Singer::other)
                :Waiter(wk,p),Singer(wk,v){}
                //错误的示范,会调用Worker的默认构造函数

对于非虚基类,显示调用Worker(const Worker&)是非法的

哪个方法?

那么问题来了,我们打算在SingingWaiter中重定义Show方法,并用SingingWaiter对象调用继承的Show方法:

//所以我傻不愣登的写下了如下代码:
SingingWaiter aha("喵喵",2017,1,soprano);
aha.Show(); //二义性,Worker和Singer都有Show() 鬼知道这个是哪个?
aha.Singer::Show(); //然而可以用作用域解析运算符来确定

最好是使用模块化:

Woeker::Data() const {
    cout << "Name: " << name;
    cout << "ID: " << id;
}
Waiter::Data() const{
    cout << "panache: " << panache << endl;
}
Singer::Data() const{
    cout << "rating: " << pv[voice] << endl;
}
SingingWaiter::Data() const{
    Worker::Data();
    Singer::Data();
}
SingingWaiter::Show() const{
    Worker::Data();
    Data();
}
//就是.........有点麻烦...