【C++】类与对象（中）（构造函数、析构函数、拷贝构造函数）-CSDN博客

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();
 Date d2;
 d2.Init(2022, 7, 6);
 d2.Print();
 return 0;
}

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

1.概念

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

2.特性

构造函数虽然名称叫构造，但是构造函数的主要任务是初始化对象，并不是开空间创建对象。

特性：

1.函数名与类名相同。

2.无返回值。

3.对象实例化时编译器自动调用对应的构造函数。

4.构造函数可以重载。（可以写多个，定义多种初始化方式）

class Date
{
public:
	//1.无参构造函数
	Date()
	{}

	//2.带参构造函数
	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;//调用无参构造函数
	Date d2(2024, 4, 28);
	d2.Print();

	Date d3();//warning

	return 0;
}

小贴士：

1.这两个 Date函数构成函数重载（参数不同/类型不同/类型顺序不同），但是在（不传参数的调用）无参调用时会存在调用歧义（既可以调用无参的构造，也可以调用全缺省的构造），一般情况下，如果要写构造函数的话，建议只写成一个全缺省的构造函数。

2.通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明。

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

看到这里想必宝子们看到生成的随机值有一些疑问？关于编译器生成的默认成员函数，不实现构造函数的情况下，编译器会生成默认的构造函数，但是看起来默认构造函数又没有什么作用？？生成的是随机值，其实并不是没有用，请接着往下看：

6.C++中，编译器自动生成的构造函数，对内置类型成员变量没有规定要不要处理，看编译器处不处理（有些编译器会处理）；对自定义类型成员才会调用它的构造函数（默认生成的构造或自己写的构造【不传参的构造或者全缺省的构造】）

看看例子：

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	//默认生成构造函数
	//内置类型没有规定要处理（可处理，可不处理，看编译器）
	int _year;
	int _month;
	int _day;

	//自定义类型调用默认构造函数
	Time _t;
};

int main()
{
	Date d2;
	d2.Print();

	return 0;
}

显式写默认构造：

改成 Time() ----> Time(int hour)，会发生什么呢？

不写构造，编译器会自动生成：

看到这里，想必大家又有一些不舒服的地方，内置类型老是会产生一些随机值，为此C++11 中对内置类型成员不初始化的缺陷，打了补丁，即：内置类型成员变量在类中声明就可以给默认值（也可以理解为给缺省值）

7.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。（三个只能存在一个，同时存在会产生歧义）

默认构造：不传参数就可以调用的函数。

小结：

自定义类型的尽头还是内置类型（因此要给缺省值进行初始化）

三、析构函数

1.概念

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

2.特性

析构函数是特殊的成员函数，特征：

1.析构函数名是在类名前加上字符~。

2.无参数无返回值类型。

3.一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。

注意：析构函数不能重载。

4.对象生命周期结束时，C++编译系统系统自动调用析构函数。

5.关于编译器自动生成的析构函数，与构造函数类似，对内置类型不做处理，对自定义类型去调用他的析构函数。

注意：创建哪个类的对象则调用该类的析构函数，销毁哪个类的对象则调用该类的析构函数。

注意：

因此我们应该在什么情况下，才要写显式的析构函数呢？

小结：

1.显式析构函数：有资源需要显示清理，如：Stack、List

2.不显式析构函数：

（1）没有资源需要清理，如：Date

（2）内置类型成员没有资源需要清理，剩下的都是自定义类型成员，如：MyQueue

要显式写：

不用显式写：

四、拷贝构造函数

1.概念

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

2.特性

拷贝构造函数也是特殊的成员函数。特征：

1.拷贝构造函数是构造函数的一个重载形式。

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

引用与不引用的区别：

引用：

不引用：

3.若未显式定义，编译器会生成默认的拷贝函数。默认的拷贝构造函数对象按内存存储字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

class Time
{
public:
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}
	Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
		cout << "Time::Time(const Time&)" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d1;

	// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
	// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
	Date d2(d1);
	//Date d2 = d1; //也可以写成这种形式
	return 0;
}

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。

4.编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？

看实际情况而定，例如：栈的拷贝要显式实现，不然程序会发生崩溃。

typedef int DateType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = (DateType*)malloc(sizeof(DateType) * capacity);
		if (NULL == _array)
		{
			perror("malloc fail");
			return;
		}

		_capacity = capacity;
		_size = 0;
	}

	void Push(DateType data)
	{
		_array[_size] = data;
		_size++;
	}

	//Stack(const Stack& st)//不写拷贝构造，程序会发生崩溃
	//{
	//	this->_array = (DateType*)malloc(sizeof(DateType) * st._capacity);
	//	if (_array == NULL)
	//	{
	//		perror("malloc fail");
	//		return;
	//	}
	//	memcpy(_array, st._array, sizeof(DateType) * st._size);

	//	_size = st._size;
	//	_capacity = st._capacity;
	//}

	//其他方法......
	~Stack()
	{
		cout << "~Stack()" << endl;

		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}

private:
	DateType* _array;
	int _capacity;
	int _size;
};

int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);

	//拷贝构造
	Stack st2(st1);

	return 0;
}

为什么呢？问题出现在哪里呢？对同一块空间析构两次！！

s1对象调用构造函数，默认申请了空间，s2对象使用了s1拷贝构造，而Stack没有显式定义拷贝构造函数，则编译器会给Stack类生成一份默认的拷贝构造函数，默认拷贝构造函数是按照值拷贝的，即将s1中的内容原封不动的拷贝到s2中，因此s2和s1指向同一块空间。

当程序退出时，s2和s1要销毁，s2先销毁，s2销毁时调用析构函数，已经将空间释放掉了，但是s1并不知道，到s1销毁时会将空间在释放一次，一块空间多次释放，会造成程序崩溃。

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请

时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

5. 拷贝构造函数典型调用场景：
（1）使用已存在对象创建新对象
（2）函数参数类型为类类型对象
（3）函数返回值类型为类类型对象

class Date
{
public:
     Date(int year, int minute, int day)
     {
       cout << "Date(int,int,int):" << this << endl;
     }

     Date(const Date& d)
     {
       cout << "Date(const Date& d):" << this << endl;
     }

    ~Date()
    {
      cout << "~Date():" << this << endl;
    }
private:
 int _year;
 int _month;
 int _day;
};

Date Test(Date d)
  {
    Date temp(d);
    return temp;
  }

int main()
{
 Date d1(2022,1,13);
 Test(d1);
 return 0;
}

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用

尽量使用引用。

小结：

1.如果没有管理资源，一般情况下不需要写拷贝构造，默认生成的拷贝构造就可以了。（如：Date）

2.如果都是自定义类型成员，内置类型成员没有指向资源空间，也类似默认生成拷贝构造就可以。（如：MyQueue）

3.一般情况下，不需要显式写析构函数，就不需要写拷贝构造函数。

4.如果内部有指针或者一些值指向资源，需要显式写析构释放，通常就需要显式写构造完成深拷贝，（如：Stack、Queue、List...）

如若对你有帮助，记得点赞、收藏、关注哦！

若有误，望各位，在评论区留言或者私信我指点迷津！！！谢谢^ ^ ~