构造函数与虚构函数

时间  2019-11-06
标签 构造 函数 虚构 繁體版
原文   原文链接

一、构造函数和析构函数为何没有返回值？

    构造函数和析构函数是两个很是特殊的函数：它们没有返回值。这与返回值为void的函数显然不一样，后者虽然也不返回任何值，但还可让它作点别的事情，而构造函数和析构函数则不容许。ios

    在程序中建立和消除一个对象的行为很是特殊，就像出生和死亡，并且老是由编译器来调用这些函数以确保它们被执行。若是它们有返回值，要么编译器必须知道如何处理返回值，要么就只能由客户程序员本身来显式的调用构造函数与析构函数，这样一来，安全性就被破坏了。另外，析构函数不带任何参数，由于析构不需任何选项。程序员

    若是容许构造函数有返回值，在某此状况下，会引发歧义。以下两个例子
数组

class C
{
public:
    C(): x(0) {    }
    C(int i): x(i) {   }

private:
    int x;
};

    若是C的构造函数能够有返回值，好比：安全

int：int C():x(0) { return 1; } //1表示构形成功，0表示失败

    那么下列代码会发生什么事呢？
数据结构

C c = C();  //此时c.x == 1

    分析：ide

    很明显，C()调用了C的无参数构造函数，该构造函数返回int值1。函数

    按照C++的规定，C c = C();是用默认构造函数建立一个临时对象，并用这个临时对象初始化c，此时，c.x的值应该是0。spa

    可是，若是C::C()有返回值，而且返回了1（为了表示成功），则C++会用1去初始化c，即调用带参数构造函数C::C(int i)。获得的c.x便会是1。因而，语义产生了歧义。设计


    构造函数的调用之因此不设返回值，是由于构造函数的特殊性决定的。从基本语义角度来说，构造函数返回的应当是所构造的对象。不然，咱们将没法使用临时对象：指针

void f(int a) 
{...}              //(1)
void f(const C& a) 
{...}             //(2)
f(C());           //(3)，究竟调用谁？

    对于(3)，咱们但愿调用的是(2)，但若是C::C()有int类型的返回值，那么到底是调用(1)好呢，仍是调用(2)好呢？因而，咱们的重载体系，乃至整个的语法体系都会崩溃。

    这里的核心是表达式的类型：目前表达式C()的类型是类C，但若是C::C()有返回类型R，那么表达式C()的类型应当是R，而不是C，因而便会引起上述的类型问题。

二、显式调用构造函数和析构函数

#include <iostream>
using namespace std;

class MyClass
{
public:
    MyClass()
    {
        cout << "Constructors" << endl;
    }

    ~MyClass()
    {
        cout << "Destructors" << endl;
    }
};

int main()
{
    MyClass* pMyClass =  new MyClass;
    pMyClass->~MyClass();
    delete pMyClass;

    return 0;
}

    结果：

Constructors
Destructors    //这个是显示调用的析构函数
Destructors    //这个是delete调用的析构函数

    这有什么用？有时候，在对象的生命周期结束前，想先结束这个对象的时候就会派上用场了（只是终结对象，其内存空间未被释放）。直接调用析构函数并不释放对象所在的内存。


    new和delete分析： 

    new的时候，其实作了三件事：

    （1）调用::operator new分配所需内存；

    （2）调用构造函数；

    （3）返回指向新分配并构造的对象的指针。

    delete的时候，作了两件事：

    （1）调用析构函数；

    （2）调用::operator delete释放内存。

    因此推测构造函数也是能够显式调用的。作个实验：

int main()
{
    MyClass* pMyClass = (MyClass*)malloc(sizeof(MyClass));
    pMyClass->MyClass();
    // …
}

    编译pMyClass->MyClass()出错：

    error C2273: 'function-style cast' : illegal as right side of '->'operator

    它觉得MyClass是这个类型。

    解决办法有两个：

    （1）pMyClass->MyClass::MyClass();

    （2）new(pMyClass) MyClass();

    

    显示调用构造函数有什么用？

    有时候，你可能因为效率考虑要用到malloc去给类对象分配内存，由于malloc是不调用构造函数的，因此这个时候会派上用场了。

    另外下面也是能够的，虽然内置类型没有构造函数。

    int* i = (int*)malloc(sizeof(int));
    new (i) int();

三、拷贝（复制）构造函数为何不能用值传递？

当你尝试着把拷贝构造函数写成值传递的时候，会发现编译都通不过，错误信息以下：

error: invalid constructor; you probably meant 'S (const S&)' 
//大体意思是：无效的构造函数，你应该写成。。。

    当编译错误的时候你就开始纠结了，为何拷贝构造函数必定要使用引用传递呢，我上网查找了许多资料，你们的意思基本上都是说若是用值传递的话可能会产生死循环。编译器可能基于这样的缘由不容许出现值传递的拷贝构造函数，也有多是C++标准是这样规定的。

    若是真是产生死循环这个缘由的话，应该是这样子的：

class S
{
public:
    S(int x):a(x){ }
    S(const S st) //拷贝构造函数
    {
        a = st.a;
    }
private:
    int a;
};

int main()
{
    S s1(2);
    S s2(s1);
    return 0;
}

    当给s2初始化的时候调用了s2的拷贝构造函数，因为是值传递，系统会给形参st从新申请一段空间，而后调用自身的拷贝构造函数把s1的数据成员的值传给st。当调用自身的拷贝构造函数的时候又由于是值传递，因此...

    也就是说，只要调用拷贝构造函数，就会从新申请一段空间，只要从新申请一段空间，就会调用拷贝构造函数，这样一直下去就造成了一个死循环。因此拷贝构造函数必定不能是值传递。

四、构造函数/析构函数抛出异常的问题

    构造函数抛出异常：

    一、不建议在构造函数中抛出异常；

    二、构造函数抛出异常时，析构函数将不会被执行；

    C++仅仅能删除被彻底构造的对象（fully contructed objects），只有一个对象的构造函数彻底运行完毕，这个对象才能被彻底地构造。对象中的每一个数据成员应该清理本身，若是构造函数抛出异常，对象的析构函数将不会运行。若是你的对象须要撤销一些已经作了的动做（如分配了内存，打开了一个文件，或者锁定了某个信号量），这些须要被撤销的动做必须被对象内部的一个数据成员记住处理。

    析构函数抛出异常：

    在有两种状况下会调用析构函数。

    （1）在正常状况下删除一个对象，例如对象超出了做用域或被显式地delete；

    （2）异常传递的堆栈展转开解（stack-unwinding）过程当中，由异常处理系统删除一个对象。

    在上述两种状况下，调用析构函数时异常可能处于激活状态也可能没有处于激活状态。遗憾的是没有办法在析构函数内部区分出这两种状况。所以在写析构函数时你必须保守地假设有异常被激活，由于若是在一个异常被激活的同时，析构函数也抛出异常，并致使程序控制权转移到析构函数外，C++将调用terminate函数。这个函数的做用正如其名字所表示的：它终止你程序的运行，并且是当即终止，甚至连局部对象都没有被释放。

    归纳以下：

    一、析构函数不该该抛出异常；

    二、当析构函数中会有一些可能发生异常时，那么就必需要把这种可能发生的异常彻底封装在析构函数内部，决不能让它抛出函数以外；

    三、当处理另外一个异常过程当中，不要从析构函数抛出异常；

     在构造函数和析构函数中防止资源泄漏的好方法就是使用smart point（智能指针），C++ STL提供了类模板auto_ptr，用auto_ptr对象代替原始指针，你将再也不为堆对象不能被删除而担忧，即便在抛出异常时，对象也能被及时删除。由于auto_ptr的析构函数使用的是单对象形式的delete，而不是delete []，因此auto_ptr不能用于指向对象数组的指针。当复制 auto_ptr 对象或者将它的值赋给其余 auto_ptr 对象的时候，将基础对象的全部权从原来的 auto_ptr 对象转给副本，原来的 auto_ptr 对象重置为未绑定状态。所以，不能将 auto_ptrs 存储在标准库容器类型中。若是要将智能指针做为STL容器的元素，可使用Boost库里的shared_ptr。

五、构造函数与析构函数能不能重载？

简单解释：

构造不重载，怎么实现多样化？

析构没有参数，怎么重载？

总结：构造函数可重载，析构函数没法重载。

六、构造函数与析构函数的调用顺序

    构造函数的调用顺序老是以下：

    一、基类构造函数。

    若是有多个基类，则构造函数的调用顺序是某类在类派生表中出现的顺序，而不是它们在成员初始化表中的顺序。

    二、成员类对象构造函数。

    若是有多个成员类对象则构造函数的调用顺序是对象在类中被声明的顺序，而不是它们出如今成员初始化表中的顺序。

    三、派生类构造函数。

    析构函数的调用顺序与构造函数的调用顺序正好相反：首先调用派生类的析构函数；其次再调用成员类对象的析构函数；最后调用基类的析构函数。

    析构函数在下边3种状况时被调用：

    一、对象生命周期结束，被销毁时(通常类成员的指针变量与引用都i不自动调用析构函数)；

    二、delete指向对象的指针时，或delete指向对象的基类类型指针，而其基类虚构函数是虚函数时；

    三、对象i是对象o的成员，o的析构函数被调用时，对象i的析构函数也被调用。

    下面用例子来讲说构造函数的的调用顺序：

#include "stdafx.h"
#include "iostream"
using namespace std;
class Base
{
public:
    Base(){ std::cout<<"Base::Base()"<<std::endl; }
    ~Base(){ std::cout<<"Base::~Base()"<<std::endl; }
};

class Base1:public Base
{
public:
    Base1(){ std::cout<<"Base1::Base1()"<<std::endl; }
    ~Base1(){ std::cout<<"Base1::~Base1()"<<std::endl; }
};

class Derive
{
public:
    Derive(){ std::cout<<"Derive::Derive()"<<std::endl; }
    ~Derive(){ std::cout<<"Derive::~Derive()"<<std::endl; }
};

class Derive1:public Base1
{
private:
    Derive m_derive;
public:
    Derive1(){ std::cout<<"Derive1::Derive1()"<<std::endl; }
    ~Derive1(){ std::cout<<"Derive1::~Derive1()"<<std::endl; }
};

int _tmain(int argc, _TCHAR* argv[])
{
    Derive1 derive;
    return 0;
}

    运行结果是：

Base::Base()
Base1::Base1()
Derive::Derive()
Derive1::Derive1()
Derive1::~Derive1()
Derive::~Derive()
Base1::~Base1()
Base::~Base()

    那么根据上面的输出结果，进行一下讲解，构造函数的调用顺序是；首先，若是存在基类，那么先调用基类的构造函数，若是基类的构造函数中仍然存在基类，那么程序会继续进行向上查找，直到找到它最先的基类进行初始化；如上例中类Derive1，继承于类Base与Base1；其次，若是所调用的类中定义的时候存在着对象被声明，那么在基类的构造函数调用完成之后，再调用对象的构造函数，如上例中在类Derive1中声明的对象Derive m_derive；最后，将调用派生类的构造函数，如上例最后调用的是Derive1类的构造函数。


    virtual析构函数

    在C++中，构造函数不能声时为虚函数，这是由于编译器在构造对象时，必须知道确切类型，才能正确的生成对象，所以，不容许使用动态束定；其次，在构造函数执行以前，对象并不存在，没法使用指向此此对象的指针来调用构造函数，然而，析构函数是能够声明为虚函数；C++明确指出，当derived class对象经由一个base class指针被删除，而该base class带着一个non-virtual析构函数，其结果未有定义---实际执行时一般发生的是对象的derived成分没被销毁掉。

    看下面的例子：

class Base
{
public:
    Base(){ std::cout<<"Base::Base()"<<std::endl; }
    ~Base(){ std::cout<<"Base::~Base()"<<std::endl; }
};

class Derive:public Base
{
public:
    Derive(){ std::cout<<"Derive::Derive()"<<std::endl; }
    ~Derive(){ std::cout<<"Derive::~Derive()"<<std::endl; }
};

int _tmain(int argc, _TCHAR* argv[])
{
    Base* pBase = new Derive(); 
    //这种base classed的设计目的是为了用来"经过base class接口处理derived class对象"
    delete pBase;

    return 0;
}

    输出的结果是：

Base::Base()
Derive::Derive()
Base::~Base()

    从上面的输出结果能够看出，析构函数的调用结果是存在问题的，也就是说析构函数只做了局部销毁工做，这可能造成资源泄漏败坏数据结构等问题；那么解决此问题的方法很简单，给base class一个virtual析构函数；

class Base
{
public:
    Base(){ std::cout<<"Base::Base()"<<std::endl; }
    virtual ~Base(){ std::cout<<"Base::~Base()"<<std::endl; }
};

class Derive:public Base
{
public:
    Derive(){ std::cout<<"Derive::Derive()"<<std::endl; }
    ~Derive(){ std::cout<<"Derive::~Derive()"<<std::endl; }
};

int _tmain(int argc, _TCHAR* argv[])
{
    Base* pBase = new Derive();
    delete pBase;

    return 0;
}

    输出结果是：

Base::Base()
Derive::Derive()
Derive::~Derive()
Base::~Base()

    上面的输出结果正是咱们所但愿的。由此还能够看出虚函数仍是多态的基础，在C++中没有虚函数就没法实现多态特性，由于不声明为虚函数就不能实现“动态联编”，因此也就不能实现多态啦！

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程