【C++】类和对象（中）-CSDN博客

本文链接：https://blog.csdn.net/2401_84538476/article/details/141674772

前言：

上一章讲到C++类和对象（上）的内容，类是什么，类和对象的关系，本章讲类和对象（中），主要包括：构造函数、析构函数、拷贝构造函数、赋值运算符重载。

一、类的默认成员函数

通常情况下，一个类我们不写的情况下编译器会默认生成6个默认成员函数，主要学习前面四个，后两个了解即可：

构造函数：主要完成初始化工作；
析构函数：主要完成清理工作；
拷贝构造：使用同类对象初始化创建对象；
赋值重载：主要是把一个对象赋值给另一个对象；
取地址重载（2个）：主要是普通对象和const对象取地址，这两个很少会自己实现。

二、构造函数

注意：构造函数虽然名称为构造，但实际上构造函数的主要任务并不是开空间创建对象（我们常使用的局部对象是栈帧创建时，空间就开好了），**而是对象实例化时初始化对象。**构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数⾃动调⽤的特点就完美的替代的了Init。

构造函数的特点：

函数名与类名相同；
无返回值（返回值啥都不需要给，也不用viod）；
对象实例化时系统会自动调用对应的构造函数；
构造函数可以重载；
如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

 //Date(int year=2024, int month=8, int day=8)
	//{
		//_year = year;
		//_month = month;
		//_day = day;
	//}

这块代码取消注释，即变为显式定义构造函数

默认构造函数：无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数。且这三个函数有且仅有一个存在，不允许同时存在。不传实参就可以调用的构造就叫做默认构造。

  class Date
 {
public:
      //1.全缺省构造函数
	Date(int year=2024, int month=8, int day=8)
	{
		_year = year;
		_month = month;
		_day = day;
	}
      //2.带参构造函数
      Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
      
      //3.无参构造函数
      Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;//全缺省构造
	d1.Print();
    
    Date d2(2024.8.1);//带参构造
    d2.Print();
    
    Date d3;//无参构造
    d3.print();
    

	//注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法区分这⾥是函数声明还是实例化对象
	//Date d2();//错误示例

	return 0;
}

此块代码，上面所列出来的三种默认构造函数在使用的时候只能存在其一，不可同时存在，这里写在一起是为了更好的展示，实际不能这么写。

编译器默认是生成的构造对内置类型成员变量的初始化没有要求，也就是说是否初始化是不确定的，取决于编译器。

[!CAUTION]

c++把类型分成内置类型（基本类型）和自定义类型。内置类型即语言提供的原生数据类型（如int/char/double/指针等）；自定义类型就是使用class/struct等关键字自己定义的类型。

小结：构造一般都需要自己写，自己传参定义。

三、析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。

析构函数的特点：

析构函数名是在类名前加上字符**~**；
无参数无返回值。
一个类只能有一个析构函数；若未显示定义，系统会自动生成默认的析构函数。
对象生命周期结束时，系统会自动调用析构函数。
我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调⽤析构函数。

//这里以 Stack 为例，解释析构函数
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	~Stack()//析构函数
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
int main()
{
	Stack st;
	return 0;
}

若类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，如Date；有资源申请时，一定要写析构函数，否则会造成资源泄露，如Stack。
一个局部域的多个对象，C++规定后定义的先析构。

小结：析构，构造时有资源申请（如malloc或fopen）等，就需要显示写析构函数。

四、拷贝构造函数

4.1 概念：

若一个构造函数的第一个参数是自身类类型的引用，且任何额外的参数都有默认值，构造函数是一个特殊的构造函数。

4.2拷贝构造的特点：

拷贝构造函数是构造函数的一个重载；
C++规定自定义类型对象进行拷贝行为必须调用拷贝构造。
只有单个形参数，一般用const修饰；

【注】Date f()函数中，运行完后销毁，返回的ret存储在临时对象中，这个临时对象作为左边Date()的实参，临时对象具有常性，传过去导致权限放大，因此要加一个const限制，正确写法为Date(const Date& d)。
拷贝构造函数的第一个参数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用。拷贝构造函数可以有多个参数，但**第一个参数必须是类类型对象的引用，后面参数必须有缺省值。

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//Date d2(&d1)
	Date(const Date& d)
	{
		_year =d. _year;
		_month = d._month;
		_day = d._day;
	}
	//

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date d1(2024, 8, 27);
	d1.Print();

	//这里是对同类型的拷贝构造，通过同类型的对象初始化构造
	Date d2(d1);
	d2.Print();

}

若未显式定义拷贝构造，编译器会自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。

深浅拷贝

浅拷贝：浅拷贝是指复制对象时只复制其基本数据类型成员和指针成员，而不复制指针所指向的内存内容。
深拷贝：深拷贝是指在复制对象时，不仅复制基本数据类型成员和指针成员，还会为指针所所指向的内存内容分配新的空间，并把原有内容复制过去。

五、赋值运算符重载

5.1运算符重载

运算符重载是一项允许用户自定义的数据类型（如类）定义运算符的特性，实质上是函数重载的一种特殊形式，重载的函数通过关键字operator后跟重载的人运算符来命名。

int operator+(int x, int y)
{
return x - y;
}

运算符重载规则

C++不允许用户自定义运算符，只能对已有C++运算符进行重载
重载不能改变运算符运算对象的个数
重载不能改变运算符的优先级别
重载不能改变运算符的结合性
重载运算符的函数不能有默认的参数
参数的类型和数量应与运算符的语义相符。二元运算符一般有两个参数，一元运算符有一个参数。

运算符重载方式

成员函数重载：在类内部定义，函数名以“operator 运算符”的形式出现，通过类的对象调用。例如，对于类 MyClass ，可以定义 MyClass operator+(const MyClass& other) {…} 来重载加法运算符。
非成员函数重载：通常作为类的友元函数定义在类外部，参数中包含要操作的对象。例如， MyClass operator+(const MyClass& lhs, const MyClass& rhs) {…} 。
(.*) 、( :: )、 (sizeof )、 (?: )、(.) 注意以上5个运算符不能重载。
重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调⽤时就变成了对象<<cout，不符合使⽤习惯和可读性。重载为全局函数把ostream/istream放到第一个形参位置就可以了，第二个形参位置当类类型对象。

重载为全局的⾯临对象访问私有成员变量的问题
有几种方法可以解决：
1、成员放公有
2、Date提供getxxx函数
3、友元函数
4、重载为成员函数

5.2赋值运算符重载

赋值运算符重载是一个默认成员函数，⽤于完成两个已经存在的对象直接的拷贝赋值，这⾥要注意跟拷贝构造区分，拷贝构造⽤于一个对象拷贝初始化给另一个要创建的对象。

赋值运算符重载的特点：

赋值运算符重载是一个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成const 当前类类型引用，否则会传值传参会有拷贝
有返回值，且建议写成当前类类型引⽤，引用返回可以提⾼效率，有返回值目的是为了支持连续赋值场景。
没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝，对⾃定义类型成员变量会调⽤他的赋值重载函数。

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		cout << " Date(const Date& d)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	//赋值运算符重载
	Date& operator=(const Date& d)
	{
		// 不要检查⾃⼰给⾃⼰赋值的情况
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		// d1 = d2表达式的返回对象应该为d1，也就是*this
		return *this;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 7, 5);
	Date d2(d1);
	Date d3(2024, 7, 6);
	d1 = d3;
	d1.Print();
	d2.Print();
	d3.Print();

	return 0;

}

赋值运算符只能重载成类的成员函数不能重载成全局函数（因为其属于默认成员函数）

自增、自减区别

自增

前置：

前置++：返回+1后的结果；
this指向的对象函数结束后不会销毁，故以引用方式返回提高效率

后置：

为了区分，构成重载，给后置**++，强⾏增加了⼀个int形参，这个参数仅仅是为了跟前置++**构成重载区分
后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1。

//前置++
Date& Date::operator++()
{
	return *this += 1;
}
//后置++
Date Date::operator++(int)
{
	Date tmp;
	tmp += 1;
	return *this;
}

自减亦如此。