C/C++ C++ 入门（3）类和对象（中）

仍有未知等待探索

已于 2024-03-23 15:17:32 修改

阅读量1.1k

点赞数 27

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

于 2024-03-05 17:19:58 首次发布

本文链接：https://blog.csdn.net/qq_73435980/article/details/136357935

版权

C++ 专栏收录该内容

16 篇文章 1 订阅

订阅专栏

个人主页：仍有未知等待探索-CSDN博客

专题分栏：C++_仍有未知等待探索的博客-CSDN博客

欢迎各位来指教！

一、类的6个默认成员函数

一个类中什么都没有的话叫空类。

但是任何类在什么都不写的情况时，编译器会自动生成6个默认的成员函数。

默认成员函数：用户在没有显式实现的情况下，编译器会生成的成员函数。

二、构造函数

说白了，构造函数的作用就是用于类的初始化工作。

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

1、特征

构造函数虽然名字叫做构造函数，但是构造函数的主要工作并不是开空间创建对象，而是初始化对象。
函数名与类名相同。
无返回值。（不是void空返回值，而是根本不用写）
对象实例化时编译器自动调用对应的构造函数。
构造函数可以重载。
如果类中没有显式定义构造函数的话，C++编译器将会自动生成一个默认的无参构造，一旦用户显示定义了，编译器将不再生成。
#include <iostream>
using namespace std;

class date
{
public:
    // 因为用户显式定义了一个构造函数，所以编译器就不会自动生成一个默认无参构造函数 
	date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// date d1; // 调用无参构造函数(因为构造函数需要参数，所以这个对象实例化的时候会进行报错)
	date d2(2015, 1, 1); // 调用带参的构造函数

	return 0;
}
C++分为内置类型（基本类型）和自定义类型。在进行默认构造函数的时候，内置类型进行初始化，自定义类型会调用它自己的默认构造函数。（在C++11版本下，对内置类型的成员变量，可以给默认值）
class date
{
public:
	date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
private:
    // 可以类似于缺省值的模式，给内置类型默认值，在默认构造函数的时候进行初始化。
	int _year = 1;
	int _month = 2;
	int _day = 3;
};
默认构造函数有3种：无参的默认构造函数，全缺省的默认构造函数，编译器自动生成的默认构造函数。
class date
{
public:
	// 无参的
	date()
	{

	}
	// 全缺省的
	date(int year = 1, int month = 2, int day = 3)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 系统默认生成的

private:
	int _year;
	int _month;
	int _day;
};
2、构造函数写法
#include <iostream>
using namespace std;

class date
{
public:
	// 无参的构造函数
	date()
	{
		// 可以对类内的成员变量进行初始化操作
		_year = 1;
		_month = 1;
		_day = 1;
	}
	// 带参的构造函数， 也可以进行缺省参数的带参的默认构造函数
	date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	date d1; // 调用无参构造函数
	date d2(2015, 1, 1); // 调用带参的构造函数

	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
	// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
    // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
	date d3();// 为什么不能这么写，是因为无法和函数声明区分开
	return 0;
}

三、析构函数

对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

1、特征
析构函数名是在类名前加上字符 ~。
无参数无返回值类型。
一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。
对象生命周期结束时，C++编译系统系统自动调用析构函数。
// 析构函数
~date()
{
	// 完成对象中资源的清理工作
	;
}
，编译器生成的默认析构函数，对自定类型成员调用它的析构函数，对内置类型不做处理。
2、析构函数写法
class date
{
public:
	~date()
	{
		// 完成对象中资源的清理工作
		cout << "~date()" << endl;;
	}
private:
	int _year;
	int _month;
	int _day;
};

四、拷贝构造函数

用已存在的类对象对新创建的对象进行初始化。（也可以比作是相当于创建了一个双胞胎）

1、特征
拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。（如下图）
class date
{
public:
	date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
	// date(const date d) // 会产生无穷递归
	date(const date& d)// 正确的写法
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		// 如果不太容易理解的话，可以用下面的写法
		// this -> _year = d._year;
		// this -> _month = d._month;
		// this -> _day = _day;
	}
private:
	int _year;
	int _month;
	int _day;
};
若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。（值拷贝不用自己写）

一旦涉及到资源申请时（malloc，calloc，realloc，new），则拷贝构造函数是一定要写的。

五、运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数。

1、特征

函数名称：关键字operator后面接需要重载的运算符符号。
返回值类型：operator操作符(参数列表)。

2、注意
不能通过连接其他的操作符来创建新的操作符（operator@ （））。
重载操作符必须有一个类类型的参数。
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义。
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this指针。
.* :: sizeof ?: .    // 以上5个运算符不能重载

3、赋值运算符重载（对日期类）

#include <iostream>
using namespace std;

class date
{
public:
	// 构造函数
	date(int _year = 0, int _month = 0, int _day = 0)
	{
		this -> _year = _year;
		this -> _month = _month;
		this -> _day = _day;
	}
	// 打印函数
	void print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
	// 对赋值运算符进行重载
	date& operator=(date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	date d1(2024,3,5), d2, d3;

	d1.print();
	d2.print();
	d3.print();
	
	d2 = d3 = d1;

	d1.print();
	d2.print();
	d3.print();

	return 0;
}

1.为什么赋值运算符重载需要返回值？

	// 对于内置类型，赋值运算符支持这样的赋值操作
    // 赋值运算符是有返回值的，返回值就是赋值运算符左边的操作数。 
    int a1, a2, a3;
	a1 = a2 = a3 = 1;

2、赋值运算符重载能不能重载成全局函数。

不能。赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现
一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值
运算符重载只能是类的成员函数。

3、运算符重载格式

参数类型：const T&，传递引用可以提高传参效率。

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值。

检测是否自己给自己赋值。

返回*this：要复合连续赋值的含义。

4、如果用户没有显式实现

编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。（内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。需要深拷贝的话，还是需要我们自己进行实现）

4、前置加加和后置加加

// 对前置加加进行重载（重载函数名必须这么写）
date& operator++()
{
	// 因为是对日期进行加加，所以也要保证日期的正确性
	this -> _day ++;
	if (GetMonthDay(*this) < this -> _day)// // 获得当月的日期
	{
		this -> _month ++;
		this -> _day = 1;
		if (this -> _month > 12)
		{
			this -> _month = 1;
			this -> _year ++;
		}
	}
	return *this;
}

// 后置加加（里面加的参数int，无意义，只是用来进行区分前置加加的，但必须写成int，规定）
// 参数int后面加不加形参的变量名，没有要求
date operator++(int)
{
	date tmp(*this);
	++ *this;
	return tmp;
}

谢谢大家！