类的六个默认成员函数（上）

目录

构造函数

析构函数

拷贝构造函数

---

对于日期（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. 拷贝构造函数典型调用场景：
使用已存在对象创建新对象
函数参数类型为类类型对象
函数返回值类型为类类型对象
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用
尽量使用引用。

感谢大家的观看！