[C++] 类与对象（中）类中六个默认成员函数（1）

心已赠人 2023-10-14 13:09 5阅读 0赞

![b2b3fb1313624791bc2b85a3835638dd.gif][]

**目录**

1、类的六个默认成员函数

2、构造函数

2.1 构造函数的概念

2.2 特性

2.2.1 构造函数的重载：

2.2.2 全缺省的构造函数：

3、析构函数

3.1 析构函数的概念

3.2 特性

4、拷贝构造函数

4.1 拷贝构造函数的概念

4.2 特征

--------------------

## 1、类的六个默认成员函数 ##

如果一个类中什么成员都没有，简称为空类。空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

![2a599a7d38641e026f5136ae73563b59.png][]

## 2、构造函数 ##

### 2.1 构造函数的概念 ###

我们这里来看看日期类的初始化：

class Date
    {
    public:
        void Init(int year, int month, int day)
        {
            _year = year;
            _month = month;
            _day = day;
        }
        void Print()
        {
        	cout << _year << "/" << _month << "/" << _day << endl;
        }
    
    private:
        int _year;
        int _month;
        int _day;
    };
    int main()
    {
        Date d1;
        d1.Init(2022, 7, 5);
        d1.Print();
        
        return 0;
    }

运行结果：

![810a4cc51fdec3f3daabd870394709ab.png][]

我们刚接触C++，一定会这样初始化。

如果我们实例化的对象太多了，忘记初始化对象了，程序运行出来的结果可能就是随机值了，也可能出问题。

这里C++祖师爷想到了，为我们设计了构造函数。

我们先来看一下忘记初始化直接打印的结果：

![a89f0b4f06a07d74ea8287e808587a2d.png][]

这里是随机值，那这是为什么呢？我们接着往下看。

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

### 2.2 特性 ###

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

我们先写一个日期类的构造函数来看看：

class Date
    {
    public:
    	Date()//构造函数，无参构造
    	{
    		cout << "Date()" << endl;
    		_year = 1;
    		_month = 1;
    		_day = 1;
    	}
    
    	void Print()
    	{
    		cout << _year << "/" << _month << "/" << _day;
    	}
    
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };

我们测试看一下：

![81a23efd09263bb67fb789011bd48134.png][]

我们main函数里没有调用构造函数，但是这里打印了我们做的标记，这里我们实验出来了**实例化对象时构造函数是自动调用的。**  
我们再来看将我们写的构造函数注释掉会发生什么：

![8bda3700eea5ff250a6eba1efbd9b651.png][]

我们能看到，注释掉后，仍然能打印出来，只不过是随机值。因为**当我们不写，编译器会自动生成默认的构造函数，并自动调用。**

**C++将类型分为内置类型（基本类型）：如int，char，double，int\*……（自定义类型\*也是）；**

**自定义类型：如class，struct，union……。**

**并且这里我们能看出来，****对于内置类型的成员不会处理，在C++11，支持成员变量给缺省值，算是补漏洞了。**

#### 2.2.1 构造函数的重载： ####

class Date
    {
    public:
    	Date()
    	{
    		cout << "Date()" << endl;
    		_year = 1;
    		_month = 1;
    		_day = 1;
    	}
    	
    	Date(int year, int month, int day)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    	void Print()
    	{
    		cout << _year << "/" << _month << "/" << _day << endl;
    	}
    
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    int main()
    {
        Date d1;
    	d1.Print();
    	Date d2(2023, 8, 1);//这里初始化必须是这样写，这是语法
    	d2.Print();
    
        return 0;
    }

运行结果：

![c83db09676d82892370235d0fe4bc67c.png][]

**注意****：**我们在实例化对象的时候，当调用的构造函数没有参数，不能在对象后加括号，语法规定。

![0c56ff030ee0681c004d36ad15086c98.png][]

如果这样写，**编译器分不清这到底是函数声明还是在调用**。d2不会混淆是因为有传值，函数声明不会出现那样的写法。

#### 2.2.2 全缺省的构造函数： ####

我们其实可以将上面的两个构造函数合并为一个

class Date
    {
    public:
    	Date(int year = 1, int month = 1, int day = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    	void Print()
    	{
    		cout << _year << "/" << _month << "/" << _day << endl;
    	}
    
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
        Date d1;
    	d1.Print();
    
    	Date d2(2023, 8, 1);
    	d2.Print();
    
    	Date d3(2023, 9);
    	d3.Print();
    
        return 0;
    }

运行结果：

![c53bf8112f2d38d7f9b2357615c17f7b.png][]

全缺省构造函数才是最适用的。无参构造与全缺省可以同时存在，但是不建议这样写，虽然不报错，但是在调用全缺省时我们不想传参，编译器不知道我们到底想调用哪个构造，会产生二义性。

我们再看用两个栈实现队列的问题：

class Stack
    {
    public:
    	Stack(int n = 4)
    	{
    		if (n == 0)
    		{
    			_a = nullptr;
    			_size = -1;
    			_capacity = 0;
    		}
    		else
    		{
    			int* tmp = (int*)realloc(_a, sizeof(int) * n);
    			if (tmp == nullptr)
    			{
    				perror("realloc fail");
    				exit(-1);
    			}
    			_a = tmp;
    
    			_size = -1;
    			_capacity = n;
    		}
    	}
    
    	void Push(int n)
    	{
    		if (_size + 1 == _capacity)
    		{
    			int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
    			int* tmp = (int*)realloc(_a, sizeof(int) * newcapacity);
    			if (nullptr == tmp)
    			{
    				perror("realloc fail:");
    				exit(-1);
    			}
    			_a = tmp;
    			_capacity = newcapacity;
    		}
    
    		_a[_size++] = n;
    	}
    
    	int Top()
    	{
    		return _a[_size];
    	}
    
    	void Pop()
    	{
    		assert(_size > -1);
    		_size--;
    	}
    
    	void Destort()
    	{
    		free(_a);
    		_a = nullptr;
    		_size = _capacity = 0;
    	}
    
    	bool Empty()
    	{
    		return _size == -1;
    	}
    
    private:
    	int* _a;
    	int _size;
    	int _capacity;
    };
    class MyQueue
    {
    private:
    	Stack _pushst;
    	Stack _popst;
    
    };

**一般情况下都需要我们自己写构造函数，决定初始化方式，成员变量全是自定义类型，可以考虑不写构造函数。会调用自定义类型的****默认****构造函数。**

**总结：无参构造函数、全缺省构造函数、我们不写编译器默认生成的构造函数，都可以认为是默认构造函数，并且默认构造函数只能存在一个（多个并存会产生二义性）。**

## 3、析构函数 ##

### 3.1 析构函数的概念 ###

> 析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而**对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。**

### 3.2 特性 ###

> **析构函数**是特殊的成员函数，其**特征**如下：  
> 1. 析构函数名是在类名前加上字符 ~。  
> 2. 无参数无返回值类型。  
> 3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数（对内置类型不做处理，自定义类型会调用它自己的析构函数）。注意：析构函数不能重载。  
> 4. 对象生命周期结束时，C++编译系统会自动调用析构函数。

我们先来看日期类的析构：

class Date
    {
    public:
    	Date(int year = 1, int month = 1, int day = 1)
    	{
            cout << "Date(int year = 1, int month = 1, int day = 1)" << endl;
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    	void Print()
    	{
    		cout << _year << "/" << _month << "/" << _day << endl;
    	}
    
    	~Date()
    	{
    		cout << "~Date()" << endl;
    		_year = 0;
    		_month = 0;
    		_day = 0;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
    	Date d1;
    	Date d2;
    
        return 0;
    }

运行结果：

![3d99f24464b48c3db56ee4846ced650a.png][]

我们这里可以看出析构函数也是自动调用的。

我们不写，编译器自动生成默认的析构函数。

析构函数的调用顺序跟栈类似，后实例化的先析构。

**如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。**

我们**画图**来看一下：

![eabf9666fae3ad58f2a063e4d36e6e7a.png][]

栈中的析构函数就代替了栈的销毁：

![427414ae6b78be44b1aab1ceeddbceed.png][]

![f27f7ab26133a53f1c1b0ea05d0eeec6.png][]

class Stack
    {
    public:
    	Stack(int n = 4)
    	{
    		if (n == 0)
    		{
    			_a = nullptr;
    			_top = -1;
    			_capacity = 0;
    		}
    		else
    		{
    			int* tmp = (int*)realloc(_a, sizeof(int) * n);
    			if (tmp == nullptr)
    			{
    				perror("realloc fail");
    				exit(-1);
    			}
    			_a = tmp;
    
    			_top = -1;
    			_capacity = n;
    		}
    	}
    
    	~Stack()
    	{
    		free(_a);
    		_a = nullptr;
    		_top = _capacity = 0;
    	}
    	//void Destort()
    	//{
    	//	free(_a);
    	//	_a = nullptr;
    	//	_top = _capacity = 0;
    	//}
    
    	void Push(int n)
    	{
    		if (_top + 1 == _capacity)
    		{
    			int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
    			int* tmp = (int*)realloc(_a, sizeof(int) * newcapacity);
    			if (nullptr == tmp)
    			{
    				perror("realloc fail:");
    				exit(-1);
    			}
    			_a = tmp;
    			_capacity = newcapacity;
    		}
    
    		_a[_top++] = n;
    	}
    
    	int Top()
    	{
    		return _a[_top];
    	}
    
    	void Pop()
    	{
    		assert(_top > -1);
    		_top--;
    	}
    
    	bool Empty()
    	{
    		return _top == -1;
    	}
    
    private:
    	int* _a;
    	int _top;
    	int _capacity;
    };
    class MyQueue
    {
    private:
    	Stack _pushst;
    	Stack _popst;
    
    };

对于栈这样的，我们析构函数代替了销毁函数，析构函数会自动调用，以前我们需要手动调用销毁函数的接口，现在不用调用了。

**因此，构造函数和析构函数最大的优势是自动调用。**

## 4、拷贝构造函数 ##

### 4.1 拷贝构造函数的概念 ###

> **拷贝构造函数：只有单个形参**，该形参是对本**类类型对象的引用(一般常用const修饰)，**在用**已存在的类类型对象创建新对象时由编译器自动调用。**

### 4.2 特征 ###

> 拷贝构造函数也是特殊的成员函数，其**特征**如下：  
> 1. 拷贝构造函数是**构造函数的一个重载形式。**  
> 2. 拷贝构造函数的**参数只有一个且必须是同类型对象的引用**，使用**传值方式编译器会引发无穷递归调用。**  
> 3. **若未显式定义，编译器会生成默认的拷贝构造函数。** 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

拷贝构造就像是复制粘贴一样。

> **拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器会引发无穷递归调用。**

传值拷贝会发生无穷递归，我们来写一个拷贝构造函数。

class Date
    {
    public:
    	Date(int year = 1, int month = 1, int day = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    	//拷贝构造
    	Date(Date d)
    	{
    		_year = d._year;
    		_month = d._month;
    		_day = d._day;
    	}
    
    	void Print()
    	{
    		cout << _year << "/" << _month << "/" << _day << endl;
    	}
    
    	~Date()
    	{
    		_year = 0;
    		_month = 0;
    		_day = 0;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    void func(Date d)
    {
    	d.Print();
    }
    
    int main()
    {
    	Date d1(2023, 8, 2);
    	func(d1);
    
        return 0;
    }

内置类型的拷贝是直接拷贝，自定义类型的拷贝要调用拷贝构造完成。

![8d7fb1350cf64ab174a9fa7187ade74a.png][]

在vs2019中，传值传参编译器会报错：

![e4673efcdcabbe5c021a5ca029eaade3.png][]

因此，我们要是写拷贝构造函数，形参必须是同类型的引用：

![c3b429b700050c888871296cdd968017.png][]

引用是给变量起别名，析构自动调用的顺序是后定义先析构，拷贝的时候d1还没有析构，因此是可以使用引用的，这样就不会导致递归拷贝了。

我们将写的拷贝构造函数屏蔽掉，看看会如何：

class Date
    {
    public:
    	Date(int year = 1, int month = 1, int day = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    	//拷贝构造
    	//Date(Date& d)
    	//{
    	//	_year = d._year;
    	//	_month = d._month;
    	//	_day = d._day;
    	//}
    
    	void Print()
    	{
    		cout << _year << "/" << _month << "/" << _day << endl;
    	}
    
    	~Date()
    	{
    		_year = 0;
    		_month = 0;
    		_day = 0;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    int main()
    {
    	Date d1(2023, 8, 2);
    	Date d2(d1);
    	d2.Print();
    	
        return 0;
    }

运行结果：

![6c1e8ae5d0be43b79babb97aa568dd6f.png][]

我们发现，如果我们不写，还是能实现拷贝，这是因为我们不写，编译器默认生成一个拷贝构造函数，对于日期类这样的浅拷贝，默认生成的构造函数是可以实现拷贝的。

我们再来看栈的拷贝构造：

typedef int DataType;
    class Stack
    {
    public:
    	Stack(int n = 4)
    	{
    		if (n == 0)
    		{
    			_a = nullptr;
    			_size = -1;
    			_capacity = 0;
    		}
    		else
    		{
    			int* tmp = (int*)realloc(_a, sizeof(int) * n);
    			if (tmp == nullptr)
    			{
    				perror("realloc fail");
    				exit(-1);
    			}
    			_a = tmp;
    
    			_size = -1;
    			_capacity = n;
    		}
    	}
    
    	//拷贝构造
    	Stack(Stack& s)
    	{
    		_a = s._a;
    		_size = s._size;
    		_capacity = s._capacity;
    	}
    
    	~Stack()
    	{
    		free(_a);
    		_a = nullptr;
    		_size = _capacity = 0;
    	}
    
    	void Push(int n)
    	{
    		if (_size + 1 == _capacity)
    		{
    			int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
    			int* tmp = (int*)realloc(_a, sizeof(int) * newcapacity);
    			if (nullptr == tmp)
    			{
    				perror("realloc fail:");
    				exit(-1);
    			}
    			_a = tmp;
    			_capacity = newcapacity;
    		}
    
    		_a[_size++] = n;
    	}
    
    	int Top()
    	{
    		return _a[_size];
    	}
    
    	void Pop()
    	{
    		assert(_size > -1);
    		_size--;
    	}
    
    	bool Empty()
    	{
    		return _size == -1;
    	}
    
    private:
    	int* _a;
    	int _size;
    	int _capacity;
    };
    int main()
    {
    	Stack s1;
    	Stack s2(s1);
    	
        return 0;
    }

我们这里为栈写的拷贝构造，我们来试一下拷贝构造：

![25d6ac189996112cf7d45e7d19d06f2c.png][]

这里为什么引发了异常呢？

我们调试看看：

![973984c3426fe86244bcca9afa502a43.png][]

这里我们可以看到，s1的\_a与s2的\_a地址是一样的，当s2拷贝完后就会析构，s2的\_a被释放掉后，s1还会再调用一次析构函数，这时再去释放\_a，\_a的空间已经被释放过了，就会引发空指针异常的问题。

因此，对于有空间申请的对象，在写拷贝构造的时候必须要深拷贝。

我们来改正代码：

typedef int DataType;
    class Stack
    {
    public:
    	Stack(int n = 4)
    	{
    		if (n == 0)
    		{
    			_a = nullptr;
    			_size = -1;
    			_capacity = 0;
    		}
    		else
    		{
    			int* tmp = (int*)realloc(_a, sizeof(int) * n);
    			if (tmp == nullptr)
    			{
    				perror("realloc fail");
    				exit(-1);
    			}
    			_a = tmp;
    
    			_size = -1;
    			_capacity = n;
    		}
    	}
    
    	//拷贝构造
    	Stack(Stack& s)
    	{
    		cout << "Stack(Stack& s)" << endl;
    		//深拷贝
    		_a = (DataType*)malloc(sizeof(DataType) * s._capacity);
    		if (nullptr == _a)
    		{
    			perror("malloc fail:");
    			exit(-1);
    		}
    
    		memcpy(_a, s._a, sizeof(DataType) * (s._size+1));
    		_size = s._size;
    		_capacity = s._capacity;
    	}
    
    	~Stack()
    	{
    		free(_a);
    		_a = nullptr;
    		_size = _capacity = 0;
    	}
    
    	void Push(int n)
    	{
    		if (_size + 1 == _capacity)
    		{
    			int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
    			int* tmp = (int*)realloc(_a, sizeof(int) * newcapacity);
    			if (nullptr == tmp)
    			{
    				perror("realloc fail:");
    				exit(-1);
    			}
    			_a = tmp;
    			_capacity = newcapacity;
    		}
    
    		_a[_size++] = n;
    	}
    
    	int Top()
    	{
    		return _a[_size];
    	}
    
    	void Pop()
    	{
    		assert(_size > -1);
    		_size--;
    	}
    
    	bool Empty()
    	{
    		return _size == -1;
    	}
    
    private:
    	int* _a;
    	int _size;
    	int _capacity;
    };

运行结果：

![83284850d5296f1cf2970ddada35fb22.png][]

**总结：**像Date这样不需要我们实现拷贝构造，默认生成的就可以用；Stack需要我们自己实现深拷贝的拷贝构造，默认生成的会出问题；对于成员全是自定义类型的也不需要写拷贝构造，会调用自定义类型的拷贝构造函数。

**引申：**

![981ce99533e046738f73d3680812ba2d.png][]

![d7e32cca37af4e19a872d4375160266a.png][]

[b2b3fb1313624791bc2b85a3835638dd.gif]: https://img-blog.csdnimg.cn/b2b3fb1313624791bc2b85a3835638dd.gif
[2a599a7d38641e026f5136ae73563b59.png]: https://img-blog.csdnimg.cn/img_convert/2a599a7d38641e026f5136ae73563b59.png
[810a4cc51fdec3f3daabd870394709ab.png]: https://img-blog.csdnimg.cn/img_convert/810a4cc51fdec3f3daabd870394709ab.png
[a89f0b4f06a07d74ea8287e808587a2d.png]: https://img-blog.csdnimg.cn/img_convert/a89f0b4f06a07d74ea8287e808587a2d.png
[81a23efd09263bb67fb789011bd48134.png]: https://img-blog.csdnimg.cn/img_convert/81a23efd09263bb67fb789011bd48134.png
[8bda3700eea5ff250a6eba1efbd9b651.png]: https://img-blog.csdnimg.cn/img_convert/8bda3700eea5ff250a6eba1efbd9b651.png
[c83db09676d82892370235d0fe4bc67c.png]: https://img-blog.csdnimg.cn/img_convert/c83db09676d82892370235d0fe4bc67c.png
[0c56ff030ee0681c004d36ad15086c98.png]: https://img-blog.csdnimg.cn/img_convert/0c56ff030ee0681c004d36ad15086c98.png
[c53bf8112f2d38d7f9b2357615c17f7b.png]: https://img-blog.csdnimg.cn/img_convert/c53bf8112f2d38d7f9b2357615c17f7b.png
[3d99f24464b48c3db56ee4846ced650a.png]: https://img-blog.csdnimg.cn/img_convert/3d99f24464b48c3db56ee4846ced650a.png
[eabf9666fae3ad58f2a063e4d36e6e7a.png]: https://img-blog.csdnimg.cn/img_convert/eabf9666fae3ad58f2a063e4d36e6e7a.png
[427414ae6b78be44b1aab1ceeddbceed.png]: https://img-blog.csdnimg.cn/img_convert/427414ae6b78be44b1aab1ceeddbceed.png
[f27f7ab26133a53f1c1b0ea05d0eeec6.png]: https://img-blog.csdnimg.cn/img_convert/f27f7ab26133a53f1c1b0ea05d0eeec6.png
[8d7fb1350cf64ab174a9fa7187ade74a.png]: https://img-blog.csdnimg.cn/img_convert/8d7fb1350cf64ab174a9fa7187ade74a.png
[e4673efcdcabbe5c021a5ca029eaade3.png]: https://img-blog.csdnimg.cn/img_convert/e4673efcdcabbe5c021a5ca029eaade3.png
[c3b429b700050c888871296cdd968017.png]: https://img-blog.csdnimg.cn/img_convert/c3b429b700050c888871296cdd968017.png
[6c1e8ae5d0be43b79babb97aa568dd6f.png]: https://img-blog.csdnimg.cn/6c1e8ae5d0be43b79babb97aa568dd6f.png
[25d6ac189996112cf7d45e7d19d06f2c.png]: https://img-blog.csdnimg.cn/img_convert/25d6ac189996112cf7d45e7d19d06f2c.png
[973984c3426fe86244bcca9afa502a43.png]: https://img-blog.csdnimg.cn/img_convert/973984c3426fe86244bcca9afa502a43.png
[83284850d5296f1cf2970ddada35fb22.png]: https://img-blog.csdnimg.cn/img_convert/83284850d5296f1cf2970ddada35fb22.png
[981ce99533e046738f73d3680812ba2d.png]: https://img-blog.csdnimg.cn/981ce99533e046738f73d3680812ba2d.png
[d7e32cca37af4e19a872d4375160266a.png]: https://img-blog.csdnimg.cn/d7e32cca37af4e19a872d4375160266a.png