C++中构造函数调用其他函数

128 阅读 0 评论 85 点赞

我是靠谱客的博主能干柜子，最近开发中收集的这篇文章主要介绍C++中构造函数调用其他函数，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

#include <stdlib.h>
#include <iostream>
using namespace std;
struct CLS
{
int m_i;
CLS( int i ) : m_i(i){}
CLS()
{
CLS(0);
}
};
int main()
{
CLS obj;
cout << obj.m_i << endl;
system("PAUSE");
return 0;
}

打印结果是不定的，不一定为0

代码奇怪的地方在于构造函数中调用了自己的另一个构造函数

我们知道，当定义一个对象时，会按顺序做2件事情：
1）分配好内存（非静态数据成员是未初始化的）
2）调用构造函数（构造函数的本意就是初始化非静态数据成员）

显然上面代码中，CLS obj；这里已经为obj分配了内存，然后调用默认构造函数，但是默认构造函数还未执行完，却调用了另一个构造函数，这样相当于产生了一个匿名的临时CLS对象，它调用CLS(int)构造函数，将这个匿名临时对象自己的数据成员m_i初始化为0；但是obj的数据成员并没有得到初始化。于是obj的m_i是未初始化的，因此其值也是不确定的

从这里，我们归纳如下：
1）在c++里，由于构造函数允许有默认参数，使得这种构造函数调用构造函数来重用代码的需求大为减少
2）如果仅仅为了一个构造函数重用另一个构造函数的代码，那么完全可以把构造函数中的公共部分抽取出来定义一个成员函数(推荐为private),然后在每个需要这个代码的构造函数中调用该函数即可
3）偶尔我们还是希望在类的构造函数里调用另一个构造函数，可以按下面方式做：
在构造函数里调用另一个构造函数的关键是让第二个构造函数在第一次分配好的内存上执行，而不是分配新的内存，这个可以用标准库的placement new做到：

先看看标准库中placement new的定义

inline void *__cdecl operator new(size_t, void *_P)
{
return (_P);
}

可见没有分配新的内存。

在执行构造函数时，CLS()并不会调用"this"对象的CLS::CLS(int)，而是会用CLS::CLS(int)来创建一个新的临时实例对象，然后当这条语句执行完后，这个新的临时对象马上就会被销毁。这样一来，"this"对象就没有被初始化，以后使用"this"对象就有可能产生一些问题...时刻记得构造函数是用来初始化对象的，如果想偷懒，可以在构造函数里调用一个自己写的私有init()初始化函数...

另：若构造函数调用自身，则会出现无限递归调用，是不允许的

正确的方式：

struct CLS
{
int m_i;
CLS( int i ) : m_i(i){}
CLS()
{
CLS(0);
//new(this)CLS(0);
//this->CLS::CLS(0);
//CLS::CLS(1);
//this->CLS(1);
}
};

C++构造函数中调用虚函数

class Base
{
public:
Base()
{
Fuction();
}
virtual void Fuction()
{
cout << "Base::Fuction" << endl;
}
};
class A : public Base
{
public:
A()
{
Fuction();
}
virtual void Fuction()
{
cout << "A::Fuction" << endl;
}
};
// 这样定义一个A的对象，会输出什么？
A a;

首先回答标题的问题，调用当然是没有问题的，但是获得的是你想要的结果吗？或者说你想要什么样的结果？

有人说会输出：

A::Fuction
A::Fuction

如果是这样，首先我们回顾下C++对象模型里面的构造顺序，在构造一个子类对象的时候，首先会构造它的基类，如果有多层继承关系，实际上会从最顶层的基类逐层往下构造（虚继承、多重继承这里不讨论），如果是按照上面的情形进行输出的话，那就是说在构造Base的时候，也就是在Base的构造函数中调用Fuction的时候，调用了子类A的Fuction，而实际上A还没有开始构造，这样函数的行为就是完全不可预测的，因此显然不是这样，实际的输出结果是：

Base::Fuction
A::Fuction

据说在JAVA中是上一种输出（感觉有点匪夷所思）。

我们来单步看一下到底发生了什么？在A的构造函数里面首先会去调用Base的构造函数，Base的构造函数如下：

class Base
{
public:
Base()
00411600 push        ebp
00411601 mov         ebp,esp
00411603 sub         esp,0CCh
00411609 push        ebx
0041160A push        esi
0041160B push        edi
0041160C push        ecx
0041160D lea         edi,[ebp-0CCh]
00411613 mov         ecx,33h
00411618 mov         eax,0CCCCCCCCh
0041161D rep stos    dword ptr es:[edi]
0041161F pop         ecx
00411620 mov         dword ptr [ebp-8],ecx
00411623 mov         eax,dword ptr [this]
00411626 mov         dword ptr [eax],offset Base::`vftable' (41770Ch)
{
  Fuction();
0041162C mov         ecx,dword ptr [this]
0041162F call        Base::Fuction (4111A9h)

}
00411634 mov         eax,dword ptr [this]
00411637 pop         edi
00411638 pop         esi
00411639 pop         ebx
0041163A add         esp,0CCh
00411640 cmp         ebp,esp
00411642 call        @ILT+460(__RTC_CheckEsp) (4111D1h)
00411647 mov         esp,ebp
00411649 pop         ebp
0041164A ret

从单步跟踪来看，注意黑色加粗的那部分汇编代码，ecx中存放的是对象的地址（0x0012ff60，我的机器上的情况看下图，有图有真相），首先是设置vtable的地址到对象的前四个字节（不同的编译器可能不同），然后就直接调用了Base::Fuction函数，并没有走虚机制，而我们此时看虚表中的状态，虚表已经填充的是0x4111a9，注意虚表的地址0x0041770c，而此时对象地址0x0012FF60前四个字节存放的正是0x0041770c。

继续跟踪，流程又回到A的构造函数中，再次注意加粗部分的代码，从基类Base的构造函数返回后，在A的构造函数中，重设了虚表指针，现在的虚表指针是（0x417700h），同样调用Fuction的时候直接调用了A::Fuction函数，并没有使用虚机制，而且此时虚表0x417700h指向的位置存放的0x41110e正是A::Fuction的地址。

class A : public Base
{
public:
A()
00411590 push        ebp
00411591 mov         ebp,esp
00411593 sub         esp,0CCh
00411599 push        ebx
0041159A push        esi
0041159B push        edi
0041159C push        ecx
0041159D lea         edi,[ebp-0CCh]
004115A3 mov         ecx,33h
004115A8 mov         eax,0CCCCCCCCh
004115AD rep stos    dword ptr es:[edi]
004115AF pop         ecx
004115B0 mov         dword ptr [ebp-8],ecx
004115B3 mov         ecx,dword ptr [this]
004115B6 call        Base::Base (411140h)
004115BB mov         eax,dword ptr [this]
004115BE mov         dword ptr [eax],offset A::`vftable' (417700h)
{
  Fuction();
004115C4 mov         ecx,dword ptr [this]
004115C7 call        A::Fuction (41110Eh)
}
004115CC mov         eax,dword ptr [this]
004115CF pop         edi
004115D0 pop         esi
004115D1 pop         ebx
004115D2 add         esp,0CCh
004115D8 cmp         ebp,esp
004115DA call        @ILT+460(__RTC_CheckEsp) (4111D1h)
004115DF mov         esp,ebp
004115E1 pop         ebp
004115E2 ret

其实事情就是这么简单。

C++析构函数中调用虚函数

#include <iostream>
using namespace std;
class Base {
public:
Base() {cout << "base ctor "<< endl; foo();}
//virtual ~Base() {cout << "base dtor "<< endl; foo();}
virtual void foo() {cout << "foo base "<< endl; }
};
class Derived : public Base{
public:
Derived() {cout << "Derived ctor "<< endl; foo();}
//virtual ~Derived() {cout << "Derived dtor "<< endl; foo();}
virtual void foo() {cout << "foo Derived "<< endl; }
};
int main()
{
//Derived *p = new Derived();
Base *p = new Derived();
cout << sizeof(p) << endl;
delete p;
return 0;
}

在对象的析构期间，存在与上面同样的逻辑。一旦一个派生类的析构器运行起来，该对象的派生类数据成员就被假设为是未定义的值，这样以来，C++就把它们当做是不存在一样。一旦进入到基类的析构器中，该对象即变为一个基类对象，C++中各个部分（虚函数，dynamic_cast运算符等等）都这样处理。dynamic_cast只是有安全检查，不能强制将子类变成父类！

这里要特别注意：上例中的程序如果不把基类的析构函数设置为虚函数，那么在delete(p)的时候是不会释放derived中比基类中多的那部分的，也就是说不会调用derived类的的析构函数，这样就会引起所占资源没有释放，所以一直强调:基类中的析构函数一定要设置为虚函数。