目录

构造函数

析构函数

拷贝构造函数

---

对于日期（Date）类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证
每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任
务并不是开空间创建对象，而是初始化对象。
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

class Date
{
public:Date(){_year = 1;_mouth = 1;_day = 1;}Date(int year, int mouth, int day){_year = year;_mouth = mouth;_day = day;}void print(){cout << _year << ' ' << _mouth << ' ' << _day << ' ' << endl;}
private:int _year;int _mouth;int _day;
};int main()
{Date s1;Date s2(2023, 2, 2);s1.print();s2.print();return 0;
}

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦
用户显式定义编译器将不再生成。

class Date
{
public:void print(){cout << _year << '-' << _mouth << '-' << _day << endl;}
private:int _year;int _mouth;int _day;
};int main()
{Date s1;Date s2;s1.print();s2.print();return 0;
}

6. 关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会
生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默
认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的
默认构造函数并没有什么用？有一些编译器会把默认值初始化为零。
解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类
型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看
下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员
函数。

class Time
{
public:Time(){cout << "time()" << endl;_hour = 1;_minute = 1;_second = 1;}private:int _hour;int _minute;int _second;
};class Date
{
public:void print(){cout << _year << '-' << _mouth << '-' << _day << endl;}
private:int _year;int _mouth;int _day;Time _t;
};int main()
{Date s1;s1.print();return 0;
}

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在
类中声明时可以给默认值。

class Date
{
public:void print(){cout << _year << '-' << _mouth << '-' << _day << endl;}
private:int _year = 1;int _mouth = 1;int _day = 1;
};int main()
{Date s1;s1.print();return 0;
}

7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为
是默认构造函数。

• 无参构造函数: Date() {} 
• 全缺省构造函数: Date(_year = 1,_minute = 1,_day = 1){}
• 们没写编译器默认生成的构造函数: 这个就字面意思

析构函数

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
析构函数是特殊的成员函数，其特征如下：
1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构
函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

typedef int DataType;
class Stack
{
public:Stack(size_t capacity = 3){cout << "Stack(size_t capacity = 3)" << endl;_array = (DataType*)malloc(sizeof(DataType) * capacity);if (NULL == _array){perror("malloc申请空间失败!!!");return;}_capacity = capacity;_size = 0;}void Push(DataType data){_array[_size] = data;_size++;}~Stack(){cout << "~Stack()" << endl;if (_array){free(_array);_array = NULL;_capacity = 0;_size = 0;}}
private:DataType* _array;int _capacity;int _size;
};int main()
{Stack s;s.Push(1);s.Push(2);return 0;
}

5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器
生成的默认析构函数，对自定类型成员调用它的析构函数。

class myqueue
{
private:Stack s1;Stack s2;int size = 0;
};int main()
{myqueue q1;return 0;
}

编译器自动生成的析构函数与构造函数类似：

内置类型不做处理，自定义类型调用它的析构函数。
6. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如
Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

拷贝构造函数

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存
在的类类型对象创建新对象时由编译器自动调用。
拷贝构造函数也是特殊的成员函数，其特征如下：
1. 拷贝构造函数是构造函数的一个重载形式。

class Date
{
public:Date(int year = 1, int mouth = 1, int day = 1){_year = year;_mouth = mouth;_day = day;}Date(Date& b){_year = b._year;_mouth = b._mouth;_day = b._day;}void print(){cout << _year << ' ' << _mouth << ' ' << _day << ' ' << endl;}
private:int _year;int _mouth;int _day;
};int main()
{Date s1(2023,2,3);Date s2(s1);s1.print();s2.print();return 0;
}

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，
因为会引发无穷递归调用。

class Date
{
public:Date(int year = 1, int mouth = 1, int day = 1){cout << "Date(int year = 1, int mouth = 1, int day = 1)" << endl;//为了方便观察_year = year;_mouth = mouth;_day = day;}Date(Date& b){_year = b._year;_mouth = b._mouth;_day = b._day;}void print(){cout << _year << ' ' << _mouth << ' ' << _day << ' ' << endl;}
private:int _year;int _mouth;int _day;
};void func(Date d)
{d.print();
}int main()
{Date s1(2023,2,3);func(s1);return 0;
}

使用传值方式编译器为什么会直接报错：

如果是传值如下：

语法逻辑上会形成无限递归，因此拷贝的函数要使用传引用。 

那如果传指针呢？

指针是可以的，但它就不是拷贝构造了，它就是一个普通的构造函数了。
3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
义类型是调用其拷贝构造函数完成拷贝的。

typedef int DataType;
class Stack
{
public:Stack(size_t capacity = 3){cout << "Stack(size_t capacity = 3)" << endl;_array = (DataType*)malloc(sizeof(DataType) * capacity);if (NULL == _array){perror("malloc申请空间失败!!!");return;}_capacity = capacity;_size = 0;}void Push(DataType data){_array[_size] = data;_size++;}~Stack(){cout << "~Stack()" << endl;if (_array){free(_array);_array = NULL;_capacity = 0;_size = 0;}}private:DataType* _array;int _capacity;int _size;
};int main()
{Stack s1;s1.Push(1);s1.Push(1);s1.Push(1);Stack s2 = s1;return 0;
}

运行结果如下： 

 我们可以通过下图看到由于传值的原因两个对象的_array指得是同一个地址，s1._array释放置空之后，s2._array还是指向原来那块地址的。导致同一块内存释放了两次，所以报错。这就叫做浅拷贝（值拷贝）

4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？
当然像日期类这样的类是没必要的。
注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请
时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

接以上代码深拷贝代码如下：

	Stack(const Stack& s){_array = (DataType*)malloc(sizeof(DataType) * s._capacity);if (_array == nullptr){perror("malloc fail");return;}memcpy(_array, s._array, sizeof(DataType) * s._size);_size = s._size;_capacity = s._capacity;}

5. 拷贝构造函数典型调用场景：
使用已存在对象创建新对象
函数参数类型为类类型对象
函数返回值类型为类类型对象
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用
尽量使用引用。

感谢大家的观看！