学堂在线c++补充记忆20200830

关于两个比较容易混淆的知识点

一个函数参数为指向基类对象的指针

#include <iostream>
using namespace std;

class Base1{                //基类Base1定义
public:
    void display() const{
        cout << "Base1::display" << endl;
    }
};

class Base2: public Base1{  //公有派生类Base2定义
public:
    void display() const{
        cout << "Base2::display" << endl;
    }
};

class Derived: public Base2{    //公有派生类Derived定义
public:
    void display() const{
        cout << "Derived::display" << endl;
    }
};

void fun(Base1 *ptr){           //参数为指向基类对象的指针
    ptr->display();             //"对象指针->成员名"
}

int main() {
    Base1 base1;                //声明Base1类对象
    Base2 base2;
    Derived derived;

    fun(&base1);                //输出Base1::display
    fun(&base2);                //输出Base1::display
    fun(&derived);              //输出Base1::display
    return 0;
}

当派生类与基类中有相同成员时

• 若无特别限定，则通过派生类对象使用的是派生类中的同名成员。
• 如果要通过派生类对象访问基类中被隐藏的同名成员，应使用基类名和作用域操作符来限定

#include <iostream>
using namespace std;

class Base1{                //基类Base1定义
public:
    int var;
    void fun() const{
        cout << "Base1::fun" << endl;
    }
};

class Base2: public Base1{  //公有派生类Base2定义
public:
    int var;
    void fun() const{
        cout << "Base2::fun" << endl;
    }
};

class Derived: public Base2{    //公有派生类Derived定义
public:
    int var;
    void fun() const{
        cout << "Derived::fun" << endl;
    }
};



int main() {
    Derived d;
    Derived *p = &d;

    //访问Derived 成员
    d.var = 1;
    d.fun();

    //访问Base1基类成员
    d.Base1::var = 2;
    d.Base1::fun();

    //访问Base2基类成员,用指针访问也是一样的
    p->Base2::var = 3;
    p->Base2::fun();

    return 0;
}

虚基类

• 需要解决的问题

当派生类从多个基类派生，而这些基类有共同基类，则在访问此共同基类的成员时，将产生冗余，并有可能因为冗余带来不一致性

• 是否是类名::成员就可以了呢？不是的

很多成员本质上就是相同的东西（一个派生类继承于多个基类，这些基类又从同一个基类派生得到）

虚基类解决二义性和冗余问题举例：

#include <iostream>
using namespace std;
class Base0{
public:
    int var0;
    void fun0(){cout << "Member of Base0" << endl;}
};
class Base1:virtual public Base0{	//在第一级继承的时候就作为虚继承
public:
    int var1;
};

class Base2:virtual public Base0{
public:
    int var2;
};

class Derived:public Base1, public Base2{
public:
    int var;
    void fun(){cout << "Member of Derived" << endl;}
};

int main(){
    Derived d;
    d.var0 = 2;         //直接访问虚基类的数据成员
    d.fun0();           //直接访问虚基类的函数成员
    return 0;
}

我们写程序应该避免二义性

解决问题的同时带来的麻烦，虚基类的构造函数怎么写？