构造函数调用顺序（2）

上一篇说了一般的调用的顺序法则和拷贝构造函数的调用，这里着重讨论在有继承条件下构造函数的调用，包括了继承，虚继承，多继承，和之前讲的虚函数表、虚函数指针有关的知识可以联系起来看（三五法则再下一篇吧。。）

C++构造函数初始化顺序

重要！(后面的不看，记住这些也足够了)：
C++构造函数按下列顺序被调用：（1、2、3、4是按照优先级顺序来的！）
(1)任何虚拟基类的构造函数按照它们被继承的顺序构造；
(2)任何非虚拟基类的构造函数按照它们被继承的顺序构造；
(3)任何成员对象的构造函数按照它们声明的顺序调用；（如果成员对象有前面出现过的父类，那么还会调用此对象父类的构造函数一遍，因为第一遍（1）（2）是为了创建子类，第二遍调用是为了构造里面的成员对象。）
(4)类自己的构造函数。

#include <iostream>

using namespace std;

class OBJ1
{
public:
    OBJ1(){ cout <<"OBJ1\n"; }
};

class OBJ2
{
public:
    OBJ2(){ cout <<"OBJ2\n"; }
};

class Base1
{
public:
    Base1(){ cout <<"Base1\n"; }
};

class Base2
{
public:
    Base2(){ cout <<"Base2\n"; }
};

class Base3
{
public:
    Base3(){ cout <<"Base3\n"; }
};

class Base4
{
public:
    Base4(){ cout <<"Base4\n"; }
};

class Derived :public Base1, virtual public Base2,
    public Base3, virtual public Base4
{
public:
    Derived() :Base4(), Base3(), Base2(),
        Base1(), obj2(), obj1()
    {
        cout <<"Derived ok.\n";
    }
protected:
    OBJ1 obj1;
    OBJ2 obj2;
    Base1 ba1;
 };

测试部分

int main()
{
    Derived aa;
    cout <<"This is ok.\n";

    int i;
    cin >> i;

    return 0;
}

结果：

Base2
Base4
Base1
Base3
OBJ1
OBJ2

Base1

Derived ok.
This is ok.

二

struct A{
    virtual void foo(){ printf("A_foo       "); }
    virtual void bar(){ printf("A_bar       "); }
    void all(){ printf("A_all       "); foo(); }
    void lone(){ printf("A_lone       "); }
    A(){ cout << "A          ";bar(); }
};
struct B :A{
    
    B(){ cout << "B         "; all(); }
    
    void foo(){ printf("B_foo       "); lone(); }
    void bar(){ printf("B_bar        "); }
    void all(){ printf("B_all       "); }
    void unique(){ printf("B_unique       "); }
};

测试部分：

int main()
{
A *p = new B;

//输出 A A_bar B B_all
1.要创建B类对象，需先创建父类A，所以先调用A类构造函数A(){ cout << "A ";bar(); }
输出A 之后，调用bar()，虽然此时bar为虚函数，但是此时子类还没有创建（只到了调用父类构造函数阶段，何谈子类，何谈实例化，何谈继承和多态呢！！），所以此时的bar()只是父类的函数，输出A_foo ；
2.此时再调用子类B的构造函数，B(){ cout << "B "; all(); }，先输出B;再调用all()函数，此时使用虚函数多态继承原则了，因为父类的all()不是虚函数，那更应该调用子类本类里面的all函数了，所以输出B_all；

p->foo();

//输出B_foo A_lone,
因为fool为虚函数，所以调用子类void foo(){ printf("B_foo "); lone(); }，先输出B_foo; 然后调用父类lone(),即void lone(){ printf("A_lone "); }，输出A_lone;

p->all();

//输出A_all B_foo A_lone;
因为all()非虚函数，p指针为基类指针，（详细见虚函数表知识就明白了！），p指针只有被子类覆盖的虚函数和基类本身的函数，所以此处调用父类的all（）函数，而非子类的。
//void all(){ printf("A_all "); foo(); },输出A_all;然后调用foo(),他是虚函数，所以调用子类的void foo(){ printf("B_foo "); lone(); }，先输出//B_foo；再调用父类的lone()，输出A_lone；

    system("pause");
    return 0;
}

三

虽然 Base1 *bas=new Derived ; 是用Base1来做基指针，但是在创建继承类调用构造函数时，先调用父类构造函数；顺序还是之前讲的，跟那个父类的指针调用没有关系！

(1)任何虚拟基类的构造函数按照它们被继承的顺序构造；
(2)任何非虚拟基类的构造函数按照它们被继承的顺序构造；

class OBJ1
{
public:
    OBJ1(){ cout << "OBJ1\n"; }
};

class OBJ2
{
public:
    OBJ2(){ cout << "OBJ2\n"; }
};

class Base1
{
public:
    Base1(){ cout << "Base1\n"; }
};

class Base2
{
public:
    Base2(){ cout << "Base2\n"; }
};



class Derived :public Base1, virtual public Base2
{
public:
    Derived() : Base2(),
        Base1()
    {
        cout << "Derived ok.\n";
    }
protected:
    OBJ1 obj1;
    OBJ2 obj2;
    Base1 ba1;
};

int main()
{
    Base1 *bas=new Derived ;
    cout << "This is ok.\n";


    system("pause");
    return 0;
}

结果：

Base2
Base1
OBJ1
OBJ2

Base1

Derived ok.
This is ok.

#include<iostream>
using namespace std;
class B0//基类BO声明
{
public://外部接口
    virtual void display()//虚成员函数
    {
        cout << "B0::display0" << endl;
    }
};
class B1 :public B0//公有派生
{
public:
    void display() { cout << "B1::display0" << endl; }
};
class D1 : public B1//公有派生
{
public:
    void display(){ cout << "D1::display0" << endl; }
};
void fun(B0 ptr)//普通函数
{
    ptr.display();
}

测试部分
int main()
{

//如果不是指针形式指向继承类，那么不会继承虚函数，没有多态概念！！

/*
B1 b1;//声明派生类对象
D1 d1;//声明派生类对象

B0 b0=b1;//声明基类对象和指针
b0.display();
B0 b00 = d1;
b00.display(); */

B0 *b00 = &d1;
//虽然DI继承自B1，但是B1public继承B0，所以也会输出D1自己覆盖虚函数，有多态概念！！！
B1 b1;//声明派生类对象
D1 d1;//声明派生类对象
B0 *b0 = &b1;//声明基类对象和指针
b0->display();
B0 *b00 = &d1;
b00->display();
// 虚函数的动态绑定仅在 基类指针或引用绑定派生类对象时发生!
B0 *b00 = &d1; 虽然DI继承自B1，但是B1public继承B0，所以也会输出D1自己覆盖虚函数，有多态概念！！
B1 b1;//声明派生类对象
D1 d1;//声明派生类对象
B0 &b0 = b1;//声明基类对象和指针
b0.display();
B0 &b00 = d1;
b00.display();

// 此题的关键点在于fun函数，传入的参数是一个类的对象，这样，派生类作为参数传入的时候，会自动的类型转换为基类对象，这样，display就只是执行基类的函数了。选B0::display() B0::display() B0::display()

//虚函数的动态绑定仅在 基类指针或引用绑定派生类对象时发生 ，fun的形参不是指针，所以调用哪个版本的函数编译时就已经确定，根据形参静态类型确定调用B0的成员。

/*
B0 b0;//声明基类对象和指针
B1 b1;//声明派生类对象
D1 d1;//声明派生类对象
fun(b0);//调用基类B0函数成员
fun(b1);//调用派生类B1函数成员
fun(d1);//调用派生类D1函数成员
*/
system("pause");
return 0;

}

另外如果修改void函数之后如下情况都可实现动态绑定，多态！！

四—1）虚函数的动态绑定仅在 基类指针或引用绑定派生类对象时发生 ，fun的形参是指针。

void fun(B0 *ptr)//普通函数
{
ptr->display();
}

//

B0 b0;//声明基类对象和指针
B1 b1;//声明派生类对象
D1 d1;//声明派生类对象
fun(&b0);//调用基类B0函数成员
fun(&b1);//调用派生类B1函数成员
fun(&d1);//调用派生类D1函数成员

四—2）虚函数的动态绑定仅在 基类指针或引用绑定派生类对象时发生 ，fun的形参是引用。

void fun(B0 &ptr)//普通函数
{
ptr.display();
}

B0 b0;//声明基类对象和指针
B1 b1;//声明派生类对象
D1 d1;//声明派生类对象
fun(b0);//调用基类B0函数成员
fun(b1);//调用派生类B1函数成员
fun(d1);//调用派生类D1函数成员