【C++】类和对象（中）

Celia～

已于 2024-08-02 18:06:06 修改

阅读量945

点赞数 28

分类专栏： C++ 文章标签： c++ 开发语言

于 2024-08-02 17:56:54 首次发布

本文链接：https://blog.csdn.net/2302_81149370/article/details/140794963

版权

C++ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

✨✨欢迎大家来到Celia的博客✨✨

🎉🎉创作不易，请点赞关注，多多支持哦🎉🎉

所属专栏：C++

个人主页：Celia's blog~

一、类的默认成员函数

默认成员函数就是用户没有显式实现，编译器自动生成的成员函数。在C++中，共有6个默认成员函数，其中前四个尤为重要，分别是：构造函数、析构函数、拷贝构造函数、赋值重载函数。

二、构造函数

构造函数是用来初始化类内部成员的函数，在实例化一个对象时自动调用。

2.1 构造函数的特点

函数名必须与类名相同。
函数没有返回值，返回值部分什么也不用写（包括void也不用写）。
函数可以有除this外的额外参数，看需求而定。
对象实例化时，构造函数会自动调用。
构造函数可以重载。
如果用户没有自己实现一个构造函数，编译器会自动生成一个无参的默认构造函数，一旦用户显式实现了构造函数，编译器将不再自动生成。
如果不传入实参就可以被调用的构造函数叫做默认构造函数，默认构造函数包括：用户实现的无参构造函数、用户实现的全缺省构造函数，编译器自动生成的构造函数。
在编译器自动生成的构造函数中：对于类中的内置类型，构造函数是否对其初始化是不确定的，这取决于不同的编译器。对于类中的自定义类型，构造函数会自动调用它们自己的构造函数，如果它们没有默认构造函数，就会报错。若仍要初始化这些没有实现构造函数的自定义类型，就需要用到初始化列表，在本章节暂不做介绍。

class Date 
{
public:
	void Print()
	{
		cout << _year << '/' << _month << '/' << _day << endl;
	}
	//构造函数（全缺省）
	Date(int year = 2000, int month = 6, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;

};

int main()
{
    Date date1;//调用构造函数，使用缺省值
    Date date2(2005,12,20);//调用构造函数，使用实参值

    return 0;
}

三、析构函数

析构函数与构造函数的作用相反，它不是销毁对象本身，而是在对象的生命周期结束时，用来释放对象内的资源（指动态开辟的内存等）的函数。在一个对象的生命周期结束时自动调用。

3.1 析构函数的特点

析构函数名与类名相同，且名字前需要加 ~ 符号。
析构函数没有参数，没有返回值（不用写void）。
一个类只能有一个析构函数，若未显式定义，编译器会自动生成一个默认析构函数。
对象的生命周期结束时，会自动调用析构函数。
编译器自动生成的析构函数对于类中的内置类型不做处理，对于类中的自定义类型，会调用自定义类型的析构函数。
用户显式实现析构函数，若类中有自定义类型，仍会调用自定义类型的析构函数。
如果类中没有申请额外资源，可以不显式实现析构函数，直接用编译器自动生成的就可以。
对于局部定义的多个对象，C++规定后定义的先析构。

class Date 
{
public:
	void Print()
	{
		cout << _year << '/' << _month << '/' << _day << endl;
	}
	//构造函数（全缺省）
	Date(int year = 2000, int month = 6, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
        _a = (int*)malloc(sizeof(int)*5);
	}
    //析构函数
    ~Date()
	{
		free(_a);
	}
private:
	int _year;
	int _month;
	int _day;
    int* _a;

};

int main()
{
    Date date1;//调用构造函数，使用缺省值
    Date date2(2005,12,20);//调用构造函数，使用实参值

    return 0;  //调用 date1 和 date2的析构函数，date2先析构。
}

四、拷贝构造函数

拷贝构造函数是一种特殊的构造函数，它的作用是用现有的一个对象来初始化和这个对象同类型的对象。

4.1 拷贝构造函数的特点

拷贝构造函数是构造函数的重载。
第一个参数必须是自身类类型的引用，不能够传值调用。否则会引发无限递归。（稍后讲解）
C++规定，自定义类型的变量拷贝必须调用拷贝构造函数。自定义类型的传参、作为返回值都会调用拷贝构造函数。
如果用户未显式实现拷贝构造函数，编译器会自动生成一个默认拷贝构造函数。编译器自动生成的拷贝构造函数，对于内置类型会进行浅拷贝（值拷贝，一个字节一个字节地拷贝），对于自定义类型，会调用自定义类型的拷贝构造。
若是类中有额外申请的空间，必须要显式定义拷贝构造函数。否则就会出现两个对象中的指针指向同一块空间，在调用析构函数时，这块空间就会被释放两次，程序就会崩掉。
小技巧：若是一个类中显式实现了析构函数，那么它就一定需要显式实现拷贝构造函数。

4.2 关于无限递归的原因

C++规定，自定义类型的变量拷贝必须调用拷贝构造函数，传参、作为返回值都会调用拷贝构造函数。若是调用传值的拷贝构造函数会引发无限递归。

调用传参的拷贝构造函数需要传参。（调用前需先传参）
传参需要调用拷贝构造函数。（传参的过程又会调用另一个拷贝构造函数）
调用拷贝构造函数需要传参。（另一个构造函数也需要传参）
传参需要调用拷贝构造函数。（另一个构造函数传参又会调用新的拷贝构造函数）
......

//类中的拷贝构造函数
Date(const Date& date)
{
	_year = date._year;
	_month = date._month;
	_day = date._day;
}

int main()
{
	Date date(2024, 8, 1);//传值构造
	date.Print();
	
	Date date2(date);//拷贝构造
	date2.Print();
	Date date3 = date2;//拷贝构造，和上面的写法等价
	date3.Print();

	return 0;
}

五、赋值重载函数

5.1 运算符重载

当运算符被作用在自定义类型上时，C++允许用户重新定义运算符的运算逻辑。自定义类型之间使用运算符时，必须转换成对应的运算符重载，若该运算符没有被重载，则会报错。
运算符重载本质上是一个函数，该函数的函数名由“operator” + 对应的运算符组成。
重载运算符的参数个数由运算对象的个数决定。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧对象传给第一个参数，右侧对象传给第二个参数。
若运算符重载是成员函数，那么它的第一个参数就会变成隐含的this指针，实际展现的参数列表的参数个数会比运算对象少一个。
运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。
不能通过连接语法中没有的符号来创建新的操作符，如 operator@，operator#等。
.*（点星）、.（点）、sizeof、::（域访问限定符）、？：（三目运算符）这五个运算符不能被重载。
重载操作符至少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义，如：int operator+（int a, int b）;
⼀个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如如Date类重载operator-就有意义，表示两个日期之间相差的天数。但是重载operator+就没有意义。
重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。 C++规定，后置++重载时，增加⼀个int形参（例如：void operator++（int），形参名字可写可不写），跟前置++构成函数重载，方便区分（相当于是书写规范）。调用前置和后置++时，编译器会自动识别调用哪个函数。
重载<<和>>时（输入、输出），需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第一个形参位置是左侧运算对象，调用时就变成了对象<<cout，不符合使用习惯和可读性。重载为全局函数把ostream/istream放到第一个形参位置就可以了，第二个形参位置当类类型对象，这样就可以使用cin和cout来直接输出自定义类型了。
ostream& operator<<(ostream& out, const Date& date)
{
	out << date._year << "年" << date._month << "月" << date._day << "日" << endl;
	return out;
}

istream& operator>>(istream& in, Date& date)
{
	cout << "请输入年、月、日：";
	in >> date._year >> date._month >> date._day;
	return in;
}

5.1.1 代码示例

class Date 
{
public:
	void Print()
	{
		cout << _year << '/' << _month << '/' << _day << endl;
	}
	//获取当前的月份天数
	int GetMonthDay(int year, int month)
	{
		static int Month[13] = { -1,31,28,31,30,31,30,31,31,30,31,30,31 };
		if (month == 2 && ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)))
		{
			return 29;
		}
		else
			return Month[month];
	}
	//构造函数
	Date(int year = 2000, int month = 6, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//析构函数 可写可不写
	~Date(){}
	//拷贝构造函数
	Date(const Date& date)
	{
		_year = date._year;
		_month = date._month;
		_day = date._day;
	}
/*===========================================================================*/
   //（类外实现）运算符重载函数
	// 日期+=天数
	Date& operator+=(int day);
	// 日期+天数
	Date operator+(int day);
	// 日期-天数
	Date operator-(int day);
	// 日期-=天数
	Date& operator-=(int day);
	
private:
	int _year;
	int _month;
	int _day;

};

Date& Date::operator+=(int day)
{
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		++_month;
		if (_month == 13)
		{
			_year++;
			_month = 1;
		}
	}
	return *this;
}
Date& Date::operator-=(int day)
{
	_day -= day;
	while (_day < 0)
	{
		_day += GetMonthDay(_year, (_month - 1) == 0 ? 12 : (_month - 1));
		--_month;
		if (_month == 0)
		{
			_year--;
			_month = 12;
		}
	}
	return *this;
}

// 日期+天数
Date Date::operator+(int day)
{
	Date date = *this;
	date += day;
	return date;
}
// 日期-天数
Date Date::operator-(int day)
{
	Date date = *this;
	date -= day;
	return date;
}

5.1.2 调用示例

int main()
{
	Date date(2024, 8, 1);//传值构造
	date.Print();
	
    //以下两种写法等价，以+=运算示例
	date.operator+=(300);
	date += 300;

	date.Print();

	return 0;
}

5.2 赋值重载

赋值重载函数是一个默认成员函数，用于已经存在的两个对象的直接赋值。
C++规定赋值重载函数必须实现为成员函数，也就是说必须在类的内部实现，不能在类外实现。
赋值重载函数的参数建议写成const（无法改变）加自身类型的引用（节省拷贝时间）。
赋值重载函数有返回值（为了支持连续赋值）。建议写成自身类型的引用，节省时间。
若是用户未显式实现赋值重载函数，编译器会自动生成一个默认赋值重载函数。该函数会对类中的内置类型进行浅拷贝（一个字节一个字节拷贝）。对自定义类型会调用自定义类型的拷贝构造。
如果一个类中额外申请了空间，就必须显式实现赋值重载函数，否则由于浅拷贝的缘故，和拷贝构造函数一样，同一块空间会被释放两次，会导致程序的崩溃。
小技巧：如果一个类显式实现了析构函数，那么这个类一定需要显式实现赋值重载函数。

//类中的赋值运算符重载函数
Date& operator=(const Date& date)
{
	_day = date._day;
	_month = date._month;
	_year = date._year;

	return *this;
}

int main()
{
	Date date(2024, 8, 1);//传值构造
	date.Print();
	
	Date date2(2000, 1, 1);
	date2.Print();

	//赋值重载，以下两种写法等价
	date2 = date;
	date2.operator=(date);

	date2.Print();

	return 0;
}