C++构造函数初始化顺序
C++构造函数按下列顺序被调用:(1、2、3、4是按照优先级顺序来的!)
(1)任何虚拟基类的构造函数按照它们被继承的顺序构造;
(2)任何非虚拟基类的构造函数按照它们被继承的顺序构造;
(3)任何成员对象的构造函数按照它们声明的顺序调用;(如果成员对象有前面出现过的父类,那么还会调用此对象父类的构造函数一遍,因为第一遍(1)(2)是为了创建子类,第二遍调用是为了构造里面的成员对象。)
(4)类自己的构造函数。
#includeusing 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
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的形参是引用。
B0 b0;//声明基类对象和指针
B1 b1;//声明派生类对象
D1 d1;//声明派生类对象
fun(b0);//调用基类B0函数成员
fun(b1);//调用派生类B1函数成员
fun(d1);//调用派生类D1函数成员