自定义类型的初始化和清理太麻烦? C++: 无所谓我会出手 - 类与对象(中篇)-C++详解六大成员函数

已于 2023-03-06 16:37:33 修改
阅读量196 收藏 1
点赞数 2
分类专栏： C++ 文章标签： c++ 开发语言 算法
于 2023-03-05 10:48:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_myhome/article/details/129342443
版权

文章目录

类与对象(中篇)

前言

在学习数据结构的时候，如果我们用面向过程的语言去实现也就是C语言，我们经常要对自定义类型的数据进行初始化和释放内存的操作，不论是对自定义类型的数据的初始化还是内存的释放使用起来都很繁琐，我们有时可能忘记对其初始化或内存释放，造成程序错误和内存泄漏等问题，C++就有办法去简化这部分操作，不用我们再手动的进行自定义类型的数据初始化和释放内存操作，实现这个过程靠的是C++类中默认成员函数。

1. 类的6个默认成员函数

默认成员函数就是即使你不去定义也会由编译器生成默认存在的函数，默认成员函数是类的重要组成部分。

即使是一个成员都没有写的空类，编译器也会自动为其生成6个默认成员函数。

image-20230303193441381

默认成员函数，对实例化对象的成员变量进行操作。

2. 构造函数

2.1 概念

在前言中我们提到，C++默认成员函数能够自动对自定义类型的数据进行初始化操作，这个过程靠的就是构造函数。

#include <iostream>

using namespace std;

class Date
{
public:
	Date()//构造函数
	{
		_year = 0;
		_month = 0;
		_day = 0;
	}

	//Date(int year = 0, int month = 0, int day = 0)//构造函数的错误重载，调用时与无参构造函数冲突
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}

	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 d1();//调用无参构造函数不能这么写，因为这样编译器无法识别它是函数的声明还是类对象实例化
	Date d2(2023, 3, 3);
	return 0;
}

image-20230303165803035

通过上面代码的结果我们可以看出，在类对象实例化时，会根据参数自动调用构造函数，构造函数中实现了类对象的初始化，我们不用手动去调用，编译器自动会调用完成初始化。

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

2.2 特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

其特征如下：

  1. 函数名与类名相同。
  2. 无返回值。
  3. 对象实例化时编译器自动调用对应的构造函数。
  4. 构造函数可以重载。
  5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
  6. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数(不传参数能够调用的构造函数)。

2.3 默认生成构造函数的特性

前面提到了默认成员函数编译器自动会生成，如果我们写了任意一种构造函数(有参数或无参数)，编译器就不会调用默认生成的构造函数，既然编译器会自动生成构造函数，我们还有必要自己去写构造函数吗？

class Date
{
public:
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	d1.Print();
	return 0;
}

image-20230303182707581

通过上面这段代码的结果可以看出，默认生成的构造函数没有对类对象进行合理的初始化，

默认生成构造函数的特性：

  1. 内置数据类型不做处理(int/double/char…等类型)。 (有的编译器会擅自处理内置数据类型)
  2. 自定义类型的成员，会去调用它的默认构造函数(无参数/全缺省的/编译器自动生成的构造函数)。

注意：实际上只要我们不对自定义类型成员变量进行处理，编译器就会调用其默认构造函数，比如显式的写一个构造函数不处理自定义类型成员变量。

#include <iostream>
#include <errno.h>

using namespace std;

class Stack
{
public:
	Stack(int n = 4)
	{
		cout << "Stack()" << endl;
		int* tmp = (int*)malloc(sizeof(int) * n);
		if (tmp == nullptr)
		{
			perror("malloc fail");
		}
		_a = tmp;
		_size = 0;
		_capacity = n;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_size = 0;
		_capacity = 0;
	}
private:
	int* _a;
	int _size;
	int _capacity;
};

class Queue
{
public:
	Queue()
	{
		cout << "Queue()" << endl;//显式写一个构造函数对自定义类型成员变量不做处理
	}
private:
	Stack popst;
	Stack pushst;
};

int main()
{
	Queue q;
	return 0;
}

image-20230306104605584

由于默认生成的构造函数的特性，需要对内置数据类型初始化时还是需要写构造函数，但是如果自定义类型的成员只是包含其他自定义类型就不需要自己写构造函数(被包含自定义类型的成员的构造函数已写出)。

class Stack
{
public:
	Stack(int n = 4)//构造函数
	{
		_a = (int*)malloc(sizeof(int) * n);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		_size = 0;
		_capacity = n;
	}
	~Stack()//析构函数
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_size = 0;
		_capacity = 0;
	}
private:
	int* _a;
	int _size;
	int _capacity;
};

class Queue
{

	//使用默认生成的构造函数

private:
	Stack popst;
	Stack pushst;
};

int main()
{
	Queue q;

	return 0;
}

image-20230303184616947

可以看出自定义类型Queue默认生成的构造函数调用了自定义类型Stack的构造函数对其包含其他自定义类型Stack进行了初始化。

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。

缺省值不是初始化，只是在使用默认生成构造函数会被使用。

class Date
{
public:
	
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
    
private:
	int _year = 1;
	int _month = 1;
	int _day = 1;
};

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

	return 0;
}

image-20230303191711033

3. 析构函数

3.1 概念

有了构造函数对自定义类型数据进行初始化，当然就会有自动对自定义类型数据的清理的操作，这个函数不会清理掉实例化出的对象，因为没必要，实例化出的对象会在栈帧结束自动销毁，比如申请的空间需要销毁，这个操作就是又另一个默认成员函数，析构函数完成的。

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

class Stack
{
public:
	Stack(int n = 4)//构造函数
	{
		_a = (int*)malloc(sizeof(int) * n);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		_size = 0;
		_capacity = n;
	}
	~Stack()//析构函数
	{
		cout << "~Stack()" << endl;//显示析构函数是否调用
		free(_a);
		_a = nullptr;
		_size = 0;
		_capacity = 0;
	}
private:
	int* _a;
	int _size;
	int _capacity;
};

int main()
{
	Stack st;
	return 0;
}

image-20230303180715571

我们可以看出，没有显式调用析构函数，但是编译器自动调用了析构函数。

3.2 特性

  1. 析构函数名是在类名前加上字符 ~。
  2. 无参数无返回值类型。
  3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构 函数不能重载
  4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

3.3 默认生成析构函数的特性

前面提到了默认生成的构造函数对自定义类型不做处理，对于自定义类型会调用其默认构造函数，默认生成的析构函数也有类似的特性，

对于内置数据类型不做处理，对于自定义类型的成员自动调用其默认析构函数。

class Stack
{
public:
	Stack(int n = 4)//构造函数
	{
		_a = (int*)malloc(sizeof(int) * n);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		_size = 0;
		_capacity = n;
	}
	~Stack()//析构函数
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_size = 0;
		_capacity = 0;
	}
private:
	int* _a;
	int _size;
	int _capacity;
};

class Queue
{

	//使用默认生成的构造函数
    
    //使用默认生成的析构函数

private:
	Stack popst;
	Stack pushst;
};

int main()
{
	Queue q;

	return 0;
}

image-20230303190507990

默认生成析构函数的特性：

  1. 内置数据类型不做处理(int/double/char…等类型)。
  2. 自定义类型的成员，会去调用它的默认析构函数。

由于默认生成析构函数的特性，对于有资源申请的类，我们需要写出其析构函数，否则默认生成析构函数不能完成资源清理。

注意：实际上无论如何对于自定义类型成员变量，编译器都会调用其默认析构函数，比如显式的写一个析构函数不处理自定义类型成员变量。

#include <iostream>
#include <errno.h>

using namespace std;

class Stack
{
public:
	Stack(int n = 4)
	{
		int* tmp = (int*)malloc(sizeof(int) * n);
		if (tmp == nullptr)
		{
			perror("malloc fail");
		}
		_a = tmp;
		_size = 0;
		_capacity = n;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_size = 0;
		_capacity = 0;
	}
private:
	int* _a;
	int _size;
	int _capacity;
};

class Queue
{
public:
	Queue()
	{

	}
	~Queue()
	{
		cout << "~Queue()" << endl;
	}
private:
	Stack popst;
	Stack pushst;
};

int main()
{
	Queue q;
	return 0;
}

image-20230306104046873

甚至主动调用析构函数，编译器还是会去调用

#include <iostream>
#include <errno.h>

using namespace std;

class Stack
{
public:
	Stack(int n = 4)
	{
		int* tmp = (int*)malloc(sizeof(int) * n);
		if (tmp == nullptr)
		{
			perror("malloc fail");
		}
		_a = tmp;
		_size = 0;
		_capacity = n;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_size = 0;
		_capacity = 0;
	}
private:
	int* _a;
	int _size;
	int _capacity;
};

class Queue
{
public:
	Queue()
	{

	}
	~Queue()
	{
		popst.~Stack();
		pushst.~Stack();
		cout << "~Queue()" << endl;
	}
private:
	Stack popst;
	Stack pushst;
};

int main()
{
	Queue q;
	return 0;
}

image-20230306104249541

4. 拷贝构造函数

4.1 概念

对于内置数据类型，在创建变量时可以直接拷贝其他变量的数据，编译器可以自动完成，对于自定义类型数据，编译器会调用其拷贝构造函数。

**拷贝构造函数：**只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。是用一个对象来初始化另一个对象的成员函数

注： const 修饰会避免由于权限放大无法调用。

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)//构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}

	Date(Date& d)//拷贝构造函数
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}

	~Date(){}//析构函数
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2023, 3, 4);
	d1.Print();
	Date d2(d1);//创建类对象时使用拷贝构造  或者 Date d2 = d1;也是调用拷贝构造函数
    d2.Print();
	return 0;
}

image-20230304093950502

可以看出，利用拷贝构造函数，也可以实现像内置数据类型一样，在创建变量时直接拷贝其他变量数据。

4.2 特性

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

关于第二点特性：

image-20230304094718026

由于是传值传参，d2调用拷贝构造函数初始化d1，调用拷贝构造函数需要传值传参，因此拷贝构造函数为了初始化形参又调用了拷贝构造函数，由于拷贝构造函数为了初始化形参又调用了拷贝构造函数，拷贝构造函数调用的拷贝构造函数又调用了拷贝构造函数，无穷递归。因此定义拷贝构造函数，形参必须是引用形式。

4.3 默认生成拷贝构造函数的特性

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

既然编译器能自己实现拷贝构造函数，还需要显式实现拷贝构造函数吗？ 对于不同的自定义类型数据答案是不同的。

对下面的类型：

image-20230304100040591

浅拷贝不会造成什么问题。

#include <iostream>
#include <assert.h>

using namespace std;

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1);

	void Print();

	~Date() {}//析构函数


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

Date::Date(int year, int month, int day)//构造函数
{
	_year = year;
	_month = month;
	_day = day;
}

void Date::Print()
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

int main()
{
	Date d1(2023, 3, 4);
	Date d2(d1);

	d1.Print();
	d2.Print();

	return 0;
}

image-20230304163607457

但如果下面这个类型：

image-20230304100111707

class Stack
{
public:
	Stack(int n = 4)//构造函数
	{
		_a = (int*)malloc(sizeof(int) * n);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		_size = 0;
		_capacity = n;
	}
	~Stack()//析构函数
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_size = 0;
		_capacity = 0;
	}
private:
	int* _a;
	int _size;
	int _capacity;
};

int main()
{
	Stack st1;
	Stack st2;
	st2 = st1;

	return 0;
}

image-20230304163923510

如果使用浅拷贝，就会有两个或两个以上的对象指向同一块空间，这样会导致，一个改变数据其他的也跟着改变，造成数据的混乱，还会造成同一块空间多次释放的问题。

因此，类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请 时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

涉及到资源申请，就要进行深拷贝，也就是我们要自己写拷贝构造函数，要使得每个对象都有独立资源空间，避免冲突。

拷贝构造函数典型调用场景：

  • 使用已存在对象创建新对象

  • 函数参数类型为类类型对象

  • 函数返回值类型为类类型对象

默认生成拷贝构造函数的特性：

  1. 内置数据类型做浅拷贝(值拷贝)处理
  2. 自定义类型的成员，会去调用它的拷贝构造函数，如果没有拷贝构造函数也会进行浅拷贝。

5. 赋值运算符重载

前面讲了，如何让自定义类型自动初始化和清理资源还有如何拷贝构造，除此之外C++还提供了其他强大的功能，让自定义类型能够利用运算符，让自定义类型能够像内置类型一样进行比较，赋值等操作。该功能就是运算符重载。

5.1 运算符重载

5.1.1 概念

**C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，**也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表) (运算符有几个操作数就有几个参数，对于两个参数的运算符重载，第一个参数是左操作数，第二个参数是右操作数)

注意：

  • 不能通过连接其他符号来创建新的操作符：比如operator@ 。

  • 重载操作符必须有一个类类型参数 。

  • 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义 。

  • 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this 。

  • .* :: sizeof ?: . 注意以上5个运算符不能重载。

5.1.2 运算符重载实现

以下实现均已日期类举例

5.1.2.1 ==运算符的重载
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1);

	Date(const Date& d);

	void Print();

	~Date() {}//析构函数

	int _year;
	int _month;
	int _day;
};

Date::Date(int year, int month, int day)//构造函数
{
	_year = year;
	_month = month;
	_day = day;
}

void Date::Print()
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

Date::Date(const Date& d)//拷贝构造函数
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

bool operator==(const Date& d1, const Date& d2)// == 运算符的重载
{
	return d1._year == d2._year
		&& d1._month == d2._month
		&& d1._day == d2._day;
}

int main()
{
	Date d1(2023, 3, 4);
	Date d2(2023, 3, 5);


	//operator==(d1, d2) //由于运算符的重载是函数实现的，因此可以像调用函数一样调用
		//d1 == d2;      //会自动转化成operator==(d1, d2)
	cout << operator==(d1, d2) << endl;
	cout << (d1 == d2) << endl;

	return 0;
}

image-20230304150240596

上面的代码的运算符重载是在全局域实现的，全局域实现会产生一些问题，比如对象私有的成员变量无法访问，对于这个问题，可以在类内提供访问成员的函数，或者只能将成员变量变成公有，因此运算符的重载更适合在类内进行实现。

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1);

	Date(const Date& d);

	void Print();

	~Date() {}//析构函数

	bool operator==(const Date& d);//==运算符重载
private:
	int _year;
	int _month;
	int _day;
};

Date::Date(int year, int month, int day)//构造函数
{
	_year = year;
	_month = month;
	_day = day;
}

void Date::Print()
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

Date::Date(const Date& d)//拷贝构造函数
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

bool Date::operator==(const Date& d)//************************==运算符重载************************
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

int main()
{
	Date d1(2023, 3, 4);
	Date d2(2023, 3, 5);

	cout << d1.operator==(d2) << endl;//类内实现调用的方式不同于在全局域实现
	cout << (d1 == d2) << endl;//自动转化为 d1.operator==(d2) 
    //由于==的优先级比<<低因此要加括号

	return 0;
}

image-20230304151233101

前面我们提到了，运算符重载有几个操作数就要有几个参数，但是在类内实现时就不同了，因为有一个隐藏的参数就是this指针，因此==重载的类内实现的显式参数只有一个。

5.1.2.2 < 运算符重载
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1);

	Date(const Date& d);

	void Print();

	~Date() {}//析构函数

	bool operator==(const Date& d);//==运算符重载

	bool operator<(const Date& d);// < 运算符重载
private:
	int _year;
	int _month;
	int _day;
};

Date::Date(int year, int month, int day)//构造函数
{
	_year = year;
	_month = month;
	_day = day;
}

void Date::Print()
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

Date::Date(const Date& d)//拷贝构造函数
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

bool Date::operator==(const Date& d)//==运算符重载
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

bool Date::operator<(const Date& d)//****************** < 运算符重载******************
{
	if (_year < d._year)
	{
		return true;
	}
	else if (_year == d._year && _month < d._month)
	{
		return true;
	}
	else if (_year == d._year && _month && d._month && _day < d._day)
	{
		return true;
	}
	else//除了以上情况都不满足小于
	{
	    return false;
	}
}

int main()
{
	Date d1(2023, 3, 4);
	Date d2(2023, 3, 5);
    
	cout << (d1 < d2) << endl;

	return 0;
}

image-20230304154124465

5.1.2.3 其他比较运算符实现

前面实现了==和<运算符的重载，其他比较运算符的重载只需要进行代码的复用就能够实现。

#include <iostream>
#include <assert.h>

using namespace std;

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1);

	Date(const Date& d);

	void Print();

	~Date() {}//析构函数

	bool operator==(const Date& d);//==运算符重载
    
    bool operator!=(const Date& d)//!=运算符重载

	bool operator<(const Date& d);// < 运算符重载

	bool operator<=(const Date& d);// <= 运算符重载

	bool operator>(const Date& d);// > 运算符重载

	bool operator>=(const Date& d);// >= 运算符重载

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

Date::Date(int year, int month, int day)//构造函数
{
	_year = year;
	_month = month;
	_day = day;
}

void Date::Print()
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

Date::Date(const Date& d)//拷贝构造函数
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

bool Date::operator==(const Date& d)//==运算符重载
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

bool Date::operator!=(const Date& d)//!=运算符重载
{
	return !(*this == d);
}

bool Date::operator<(const Date& d)// < 运算符重载
{
	if (_year < d._year)
	{
		return true;
	}
	else if (_year == d._year && _month < d._month)
	{
		return true;
	}
	else if (_year == d._year && _month && d._month && _day < d._day)
	{
		return true;
	}
	else
	{
	    return false;
	}
}

bool Date::operator<=(const Date& d)// <= 运算符重载
{
	return *this < d || *this == d;
}

bool Date::operator>(const Date& d)// > 运算符重载
{
	return !(*this <= d);
}

bool Date::operator>=(const Date& d)// >= 运算符重载
{
	return !(*this < d);
}


int main()
{
	Date d1(2023, 3, 4);
	Date d2(2023, 3, 5);
    
	cout << (d1 == d2) << endl;
	cout << (d1 < d2) << endl;
	cout << (d1 <= d2) << endl;
	cout << (d1 > d2) << endl;
	cout << (d1 >= d2) << endl;

	return 0;
}

image-20230304154704049

5.1.2.4 前置++(–)和后置++(–))运算符实现
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1);

	void Print();

	Date operator+(int x);//日期加天数

	Date& operator+=(int x);

	Date& operator-=(int x);

	Date& operator++();//前置++

	Date operator++(int);//后置++

	Date& operator--();//前置--

	Date operator--(int);//后置--


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

Date::Date(int year, int month, int day)//构造函数
{
	assert(month > 0 && month < 13
		&& day > 0 && day <= GetMonthDay(year, month));
	_year = year;
	_month = month;
	_day = day;

}

void Date::Print()
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

int Date::GetMonthDay(int year, int month)//获得该月份天数
{
	assert(month > 0 && month < 13);

	int monthArray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
	{
		return 29;
	}
	else
	{
		return monthArray[month];
	}
}

Date& Date::operator+=(int x)
{
	if (x < 0)
	{
		*this -= -x;

		return *this;
	}

	_day += x;
	
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if (_month == 13)
		{
			_year++;
			_month = 1;
		}
	}

	return *this;
}


Date& Date::operator++()//前置++
{
	*this += 1;

	return *this;
}

Date Date::operator++(int)//后置++
{
	Date tmp(*this);

	*this += 1;

	return tmp;
}

Date& Date::operator-=(int x)
{
	if (x < 0)
	{
		*this += -x;

		return *this;
	}
	_day -= x;

	while (_day <= 0)
	{
		_month--;

		if (_month == 0)
		{
			_year--;
			_month = 12;
		}
		
		_day += GetMonthDay(_year, _month);
	}

	return *this;
}

Date& Date::operator--()//*****************************前置--
{
	*this -= 1;

	return *this;
}

Date Date::operator--(int)//**************后置--**************
{
	Date tmp(*this);

	*this -= 1;

	return tmp;
}

C++规定实现后置++时参数里要写一个int,这个参数仅仅是为了和前置++形成重载。

5.1.2.5 输入输出重载

image-20230304195701552

通过查看文档发现，C++中cout能够自动识别数据类型，也是得益于运算符重载。

因此，若想用cout方式输出自定义类型只需要对运算符进行重载。

但是我们不能对库函数里的运算符重载进行修改，因此只能尝试在自定义类型的类内实现。

void Date::operator<<(ostream& cout)
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

int main()
{
	Date d1(2023, 3, 4);

	d1.operator<<(cout);
    d1 << cout;

	return 0;
}

image-20230304200338129

前面说过第一个参数是第一个操作数，第二个参数是第二个操作数，在类内实现的方式会导致使用时cout在对象后面。

由于在类内实现的效果不理想，因此只能在全局域实现。

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);//此处为友元函数，友元函数使得该函数能够访问类内数据
public:
	Date(int year = 1, int month = 1, int day = 1);

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


ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;

	return cout;
}

int main()
{
	Date d1(2023, 3, 4);
	Date d2(2000, 1, 1);

	cout << d1 << d2;

	return 0;
}

image-20230304201642396

C++利用友元加运算符重载不仅很方便的实现了输出还能保护类内数据。

image-20230304202052423

同样的cin能够自动识别数据类型也是由于运算符重载。

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);

	friend istream& operator>>(istream& in, Date& d);

public:
	Date(int year = 1, int month = 1, int day = 1);

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

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;

	return cout;
}

istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;

	return in;
}

int main()
{
	Date d1(2023, 3, 4);
	Date d2(2000, 1, 1);
	cin >> d1 >> d2;
	cout << d1 << d2;

	return 0;
}

image-20230304202520166

输入和输出的重载这种短小的函数，可以考虑改成内联函数

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);

	friend istream& operator>>(istream& in, Date& d);

public:
	Date(int year = 1, int month = 1, int day = 1);

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

inline ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;

	return cout;
}

inline istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;

	return in;
}

int main()
{
	Date d1(2023, 3, 4);
	Date d2(2000, 1, 1);
	cin >> d1 >> d2;
	cout << d1 << d2;

	return 0;
}

需要注意的是内联函数声明和定义不能分离，如果分离是只能找到声明，无法通过符号表找到定义。

另外由于在类内定义的函数默认被当作内联函数，因此短小的函数可以考虑直接定义在类内。

5.2 赋值运算符重载

#include <iostream>
#include <assert.h>

using namespace std;

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1);

	Date(const Date& d);

	void Print();

	~Date() {}//析构函数

	Date& operator=(const Date& d);// = 运算符重载

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

Date::Date(int year, int month, int day)//构造函数
{
	_year = year;
	_month = month;
	_day = day;
}

void Date::Print()
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

Date::Date(const Date& d)//拷贝构造函数
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

Date& Date::operator=(const Date& d)//***************** = 运算符重载************************
{
	if (this != &d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	return *this;
}

int main()
{
	Date d1(2023, 3, 4);
	Date d2(2023, 3, 5);
	Date d3(2023, 8, 8);

	d1 = d2 = d3;
	return 0;
}

image-20230304160048179

赋值运算符重载特性：

  • 参数类型：const T&，传递引用可以提高传参效率
  • 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
  • 检测是否自己给自己赋值
  • 返回*this ：要复合连续赋值的含义

5.3默认生成赋值运算符的特性

赋值运算符也是成员函数之一，因此即使我们不显式的去写，编译器也会默认生成，和拷贝构造函数类似，对于内置类型进行浅拷贝，对于自定义类型，会调用其赋值运算符，如果未定义也会调用默认生成的赋值运算符，默认生成的赋值运算符会对对象进行浅拷贝操作。

#include <iostream>
#include <assert.h>

using namespace std;

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1);

	Date(const Date& d);

	void Print();

	~Date() {}//析构函数


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

Date::Date(int year, int month, int day)//构造函数
{
	_year = year;
	_month = month;
	_day = day;
}

void Date::Print()
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

Date::Date(const Date& d)//拷贝构造函数
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

int main()
{
	Date d1(2023, 3, 4);
	Date d2(2023, 3, 5);
	Date d3(2023, 8, 8);

	d1 = d2 = d3;//使用默认生成的赋值运算符

	d1.Print();
	d2.Print();
	d3.Print();
    
	return 0;
}

image-20230304162054287

默认生成赋值运算符特性：

  • 对于内置类型，进行浅拷贝
  • 对于自定义类型，调用该成员的赋值运算符，如果未定义也会调用默认生成的赋值运算符(浅拷贝)。

6. 四大成员函数默认生成特性总结

构造函数/析构函数：

  • 对于内置类型，不进行处理
  • 对于自定义类型成员，会去调用它的默认构造函数(无参数/全缺省的/编译器自动生成的构造函数)。

拷贝构造函数/赋值运算符：

  • 对于内置类型，进行浅拷贝
  • 对于自定义类型，调用该成员的拷贝构造函数/赋值运算符，(如果未定义也会调用默认生成也就是进行浅拷贝)。

7. const成员

定义：将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数 隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

#include <iostream>

using namespace std;

class A
{
public:
	void Print()
	{
		cout << _a << endl;
	}
private:
	int _a = 10;
};

int main()
{
	const A aa;
	aa.Print();
	return 0;
}

image-20230304203926118

为什么如上代码，编译器报错了呢？是因为this指针是A*const类型(this的指向不能改变)，而aa定义的是const类型，传入print函数时权限被放大了。为了调用函数我们需要改变this的类型，但我们不能显式的改变this的类型，但C++规定我们可以使用如下方式this类型：

#include <iostream>

using namespace std;

class A
{
public:
	void Print()const//将this指针改为const A* const类型
	{
		cout << _a << endl;
	}
private:
	int _a = 10;
};

int main()
{
	const A aa;
	aa.Print();
	return 0;
}

image-20230304204432216

既然this可以被const修饰，对于不改变成员变量的函数，最好都要加上const修饰(如果声明和定义分离，声明和定义都要加)，可以使得const对象和普通对象都能调用。

8. 取地址及const取地址操作符重载

相较于其他四个成员函数，这个两个成员函数就没有那么重要，这两个默认成员函数一般不用重新定义 ，编译器默认会生成。这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

#include <iostream>

using namespace std;

class A
{
public:
	void Print()const
	{
		cout << _a << endl;
	}
private:
	int _a = 10;
};

int main()
{
	A aa;
	const A bb;

	cout << &aa << endl;
	cout << &bb << endl;

	return 0;
}

image-20230304210041741

以上是编译器自动生成的取地址及const取地址操作符重载的使用演示。

如果我们要模拟实现也很简单：

#include <iostream>

using namespace std;

class A
{
public:
	void Print()const
	{
		cout << _a << endl;
	}
	A* operator&()
	{
		return this;
	}
	const A* operator&()const
	{
		return this;
	}
private:
	int _a = 10;
};

int main()
{
	A aa;
	const A bb;

	cout << &aa << endl;
	cout << &bb << endl;

	return 0;
}

9. 日期类完整实现

日期类完整的代码实现戳这里：Date/Date · 钱雪明/日常代码 - 码云 - 开源中国 (gitee.com)

好想写博客
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++类静态成员与类静态成员函数详解
01-20
也不能在类的构造函数中初始化该成员，因为静态数据成员为类的各个对象共享，否则每次创建一个类的对象则静态数据成员都要被重新初始化。 静态成员不可在类体内进行赋值，因为它是被所有该类的对象所
C++类与对象（二）
Hello World！
09-16 963
类的六个默认成员函数 如果一个类中什么成员都没有，简称为空类，可是空类中就什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下列六个成员函数： 构造函数 构造函数是一个特殊的成员函数，名字与类型相同，创建类型对象时有编译器自动调用，保证每个数据成员都有一个合适的初值，并且在对象的生命周期内只调用一次 特性 构造函数是特殊的成员函数，构造函数虽然名称为构造，但是需要注意的是构造函数...
C++ 对象初始化
yly的博客
08-05 4552
在类的声明时可以初始化，但不能使用（）括号方式初始化。 1. 类模板 允许的参数类型 2. 类构造函数初始化顺序 3.
c++自定义类对象的初始化_类装载器
weixin_39882948的博客
12-29 345
一、类的生命周期类从被加载到虚拟机内存中开始，直到从内存中卸载为止，它的整个生命周期包括了：加载、验证、准备、解析、初始化、使用和卸载这7个阶段。其中，验证、准备和解析这三个部分统称为链接（linking）。graph LR A[加载] --> B[验证] B --> C[准备] C --> D[解析] D --> E[初始化] E --> F[使用] F --&gt...
【C++】构造函数 利用构造函数对类对象进行初始化
热门推荐
TPON的博客
01-25 1万+
有关构造函数与析构函数的知识点
C++ 深度解析教程（六）对象的构造、初始化列表的使用
Exp.Joker
06-15 683
对象的构造（上）1、问题：对象中成员变量的初始值是多少？2、小实验：下面的类定义中成员变量i和j的初始值为什么?编程实验：成员变量的初始值3、对象的初始化4、构造函数 5、小结十八、对象的构造（中）1、构造函数注意：初始化和赋值是完全不一样的。2、小实例3、编程实验：数组类的实现4、小结十九、对象的构造（下）1、特殊的构造函数2、拷贝构造函数3、什么时候需要进行深拷贝？4、编程实验：数组类的改进IntArray.cIntArray.hmain.c5、小结二十、初始化列表的使用1、问题：类中是否可以定义...
C++初阶学习-类和对象（中篇）
总结日常学习内容
04-12 220
详解类的6个默认成员函数，超详细包学会
C++ 11新特性之大括号初始化详解
01-01
本文主要给大家介绍了关于C++11新特性之大括号初始化的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍： C++11之前，C++主要有以下几种初始化方式： //小括号初始化 string str(hello); ...
关于C++类的成员初始化列表的相关问题
09-02
下面小编就为大家带来一篇关于C++类的成员初始化列表的相关问题。小编觉得挺
C++ 静态成员的类内初始化详解及实例代码
12-26
一般来说，关于C++类静态成员的初始化，并不会让人感到难以理解，但是提到C++ 静态成员的”类内初始化”那就容易迷糊了。 我们来看如下代码： //example.h #include #include using namespace std; class Example{ ...
C++类的静态成员初始化详细讲解
09-05
通常静态数据成员在类声明中声明,在包含类方法的文件中初始化.初始化时使用作用域操作符来指出静态成员所属的类.但如果静态成员是整型或是枚举型const,则可以在类声明中初始化
类加载机制
晏霖/胖虎的博客
11-19 179
点击上方“晏霖”，选择“置顶或者星标”曾经有人关注了我后来他有了女朋友1.6类加载机制1.6.1概述学习本章前我们要对类文件结构有一个简单的认识，而学习类文件结构没有任何难度，更多的是参...
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 619
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 408
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ 11
qq_65112813的博客
05-17 657
对于类类型，如果定义了接受。
手搓顺序表（C语言）
最新发布
m0_62646213的博客
05-19 818
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
【C++】＜知识点＞ 类的大小计算
致力于Linux的博客
05-18 116
C++中使用sizeof计算类大小的内在说明。
[原创](Modern C++)现代C++的std::function, 强大的多态函数包装器(包含std::mem_fn使用方式).
其实我不是代码教父,我只是猪头三
05-15 290
std::function的主要作用是:存储, 复制和调用任何函数(通过指向它的指针), lambda表达式, 绑定表达式或其他函数对象, 以及指向成员函数的指针和指向数据成员的指针.
C++中为创建的类自定义构造函数，实现对成员变量的初始化
05-05
在结构体中，我们可以定义成员变量和函数指针，但是无法像 C++ 中那样定义构造函数。 不过，我们可以通过手动编写一个函数来实现对成员变量的初始化。这个函数可以被看作是一个自定义的构造函数，我们可以将其命名...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

好想写博客

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值