c++中的构造函数和析构函数

（一）：构造函数、析构函数、赋值与初始化、explicit关键字                     

构造函数是为了保证对象的每个数据成员都被正确初始化

通常情况下构造函数应声明为公有函数，一般被隐式地调用。
构造函数被声明为私有有特殊的用途，比如单例模式，以后详谈。
构造函数可以有任意类型和任意个数的参数，一个类可以有多个构造

默认构造函数

不带参数的构造函数
如果程序中未声明，则系统自动产生出一个默认构造函数，是空函数

如果程序实现任何一个构造函数（包括拷贝构造函数），那么编译器将不再提供默认构造函数

栈上的对象生存期到了会自动调用析构函数；而new operator做了两件事，一个是创建了对象内存，一个是调用构造函数；堆上的内存需要delete释放，做了两件事，一是调用析构函数，二是释放内存

//我们不能调用一个构造函数但没有提供参数（实例化对象），如
A a();
//因为是有歧义的，我们也可以看成是声明了一个没有参数的函数a，返回值是类型A的一个对象

但在函数传参的时候往往可以这样写： A()  //即定义一个无名对象。

还有一个注意点，全局对象的构造先于main函数执行，在return 0时全局变量的生存期也到了，故也会自动调用

析构函数

没有参数

析构函数不能被重载，如果没有定义析构函数，编译器会自动生成一个默认析构函数，其格式如下：
类名::~默认析构函数名( )
{
}
默认析构函数是一个空函数

实际上，构造函数和析构函数都是可以被显式调用的，只是很少这样做，

new的时候，其实做了两件事，

一是：调用malloc分配所需内存（实际上是调用operator new），二是：调用构造函数。

delete的时候，也是做了两件事，

一是：调用析造函数，二是：调用free释放内存（实际上是调用operator delete）。

这里只是为了演示，正常情况下析构函数只会被调用一次，如果被调用两次，而析构函数内有delete的操作，会导致内存释放两次的错误

placement new的作用就是：创建对象(调用该类的构造函数)但是不分配内存，而是在已有的内存块上面创建对象。用于需要反复创建并删除的对象上，可以降低分配释放内存的性能消耗。

转换构造函数

单个参数的构造函数不一定是转换构造函数
将其它类型转换为类类型
类的构造函数只有一个参数是非常危险的，因为编译器可以使用这种构造函数把参数的类型隐式转换为类类型

赋值与初始化的区别

在初始化语句中的等号不是运算符。

#include "Test.h"

int main(void)
{
    Test t = 10;        // 等价于Test t(10); 这里的=不是运算符，表示初始化。

    t = 20;             // 赋值操作

    Test t2;
    t = t2;             // 赋值操作 t.operator=(t2);


    return 0;
}

 

 

 

 

 

explicit 关键字

只提供给类的构造函数使用的关键字。
编译器不会把声明为explicit的构造函数用于隐式转换，它只能在程序代码中显示创建对象

（二）：初始化列表（const和引用成员）、拷贝构造函数

一、构造函数初始化列表

推荐在构造函数初始化列表中进行初始化
构造函数的执行分为两个阶段

初始化段

普通计算段

一是构造对象之前，必须先构造对象的成员；二是对象成员构造的顺序与定义时的顺序有关，跟初始化列表顺序无关；三是构造的顺序和析构的顺序相反；四是如果对象成员对应的类没有默认构造函数，那对象成员也只能在初始化列表进行初始化。再提一点，如果类是继承而来，基类没有默认构造函数的时候，基类的构造函数要在派生类构造函数初始化列表中调用

（二）、const成员、引用成员的初始化

//const成员的初始化只能在构造函数初始化列表中进行
// 引用成员的初始化也只能在构造函数初始化列表中进行
// 对象成员（对象成员所对应的类没有默认构造函数）的初始化，也只能在构造函数初始化列表中进行

因为const变量或者引用都得在定义的时候初始化，所以const成员和引用成员必须在初始化列表中初始化。另外，可以使用定义枚举类型来得到类作用域共有的常量。

如果类中没有定义拷贝构造函数，则系统自动生成一个缺省复制构造函数，作为该类的公有成员，所做的事情也是简单的成员复制

（二）、拷贝构造函数调用的几种情况

当函数的形参是类的对象，调用函数时，进行形参与实参结合时使用。这时要在内存新建立一个局部对象，并把实参拷贝到新的对象中。理所当然也调

用拷贝构造函数。还有一点，为什么拷贝构造函数的参数需要是引用？ 这是因为如果拷贝构造函数中的参数不是一个引用，即形如CClass(const 

CClass c_class)，那么就相当于采用了传值的方式(pass-by-value)，而传值的方式会调用该类的拷贝构造函数，从而造成无穷递归地调用拷贝构造函

数。

当函数的返回值是类对象，函数执行完成返回调用者时使用。也是要建立一个临时对象，再返回调用者。为什么不直接用要返回的局部对象呢？

因为局部对象在离开建立它的函数时就消亡了，不可能在返回调用函数后继续生存，所以在处理这种情况时，编译系统会在调用函数的表达式中创建一

个无名临时对象，该临时对象的生存周期只在函数调用处的表达式中。所谓return对象，实际上是调用拷贝构造函数把该对象的值拷入临时对象。如果

返回的是变量，处理过程类似，只是不调用构造函数

（三）：深拷贝与浅拷贝、空类与空数组 

说得简单点，假设一个类有指针成员，如果在拷贝的时候顺带连指针指向的内存也分配了，就称为深拷贝

如果只是分配指针本身的内存，那就是浅拷贝

浅拷贝造成的问题是有两个指针指向同块内存，delete其中一个指针，那么剩下的指针将成为野指针。编译器合成的默认拷贝构造函数和赋值运算符是浅拷贝的，如果只是普通成员的赋值，浅拷贝也是可以的。

此外，如果我们想让对象是独一无二的，需要禁止拷贝，只需要将拷贝构造函数和等号运算符声明为私有，并且不提供它们的实现

注意：在编写派生类的赋值函数时，不要忘记对基类的数据成员重新赋值，可以通过调用基类的赋值函数来实现

二、空类与空数组

空类默认产生的成员：

class Empty {};
Empty(); // 默认构造函数
Empty( const Empty& ); // 默认拷贝构造函数
~Empty(); // 默认析构函数
Empty& operator=( const Empty& );  // 默认赋值运算符
Empty* operator&();               // 取址运算符
const Empty* operator&() const;    // 取址运算符 const

空类的大小为1个字节

#include<iostream>
using namespace std;
int main()
{
    int a[0];
    class B {};
    struct C
    {
        int  m;
        int  n;
        char buffer[];
    };
    class D
    {
        int  s[0];
    };

    cout << "sizeof(a)=" << sizeof(a) << endl; //0
    cout << "B{}=" << sizeof(B) << endl; //1
    cout << "C=" << sizeof(C) << endl; //8
    cout << "D=" << sizeof(D) << endl; //0

    return 0;
}