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 要创建B类对象，需先创建父类A，多以先调用A类构造函数A(){ cout << "A          ";bar(); }，输出A 之后，调用bar()，虽然此时bar为虚函数，但是此时子类还没有创建（只到了调用父类构造函数阶段，何谈子类，何谈实例化，何谈继承和多态呢！！），所以此时的
//bar()只是父类的函数，输出A_foo ；
//此时再调用子类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函数成员