【C++】类和对象（中）(万字详解)

在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定

义类型是调用其拷贝构造函数完成拷贝的。所以内置类型处理，自定义类型不处理，自定义类型可能复杂多变，需要自己写拷贝函数，这样就叫 深拷贝。

浅拷贝： 自己没有写，使用默认的  （日期类）

class Date
{
public:
   //构造函数
 Date(int year = 1900, int month = 1, int day = 1)
 {
 cout << "构造函数" << endl; //验证调用所需
 _year = year;
 _month = month;
 _day = day;
 }
 
private:
 int _year;
 int _month;
 int _day;
};
 
int main()
{
    Date d1(2022, 10, 10);
    Date d2(d1); //拷贝d1
    return 0;
}

是可以实现我们想要的功能的，所以不需要我们自己写。

举例：（栈类）

class Stack
{
public:
	Stack(int capacity = 4)
	{
		cout << "Stack(int capacity = 4)" << endl;
 
		_a = (int*)malloc(sizeof(int)*capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
 
		_top = 0;
		_capacity = capacity;
	}
	 //析构函数
	~Stack()
	{
		cout << "~Stack()" << endl;
 
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
 
	void Push(int x)
	{
		// ....
		// 扩容
		_a[_top++] = x;
	}
 
private:
	int* _a;
	int _top;
	int _capacity;
};
 
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	Stack s2(s1);
}

当使用默认拷贝函数时，是否能实现我们想要的需求：

 

 这是怎么了？？编译器自己提供的默认拷贝构造函数居然把s1拷贝到s2类中时，两个类中的指针变量指向了同一块空间！！

那么，栈的特性就是先进后出，所以s2先调用析构函数，把空间清理了，然后s1再去调用析构函数，又去清理，这不是瞎搞嘛，造成内存重复释放！

所以默认的拷贝构造函数解决不了我们的需求，需要我们自己写。

//st2(st1)拷贝构造
	Stack(const Stack& st)
	{
		cout << "Stack(const Stack& st)" << endl;
 
		_a = (int*)malloc(sizeof(int)*st._capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memcpy(_a, st._a, sizeof(int)*st._top);
		_top = st._top;
		_capacity = st._capacity;
	}

 即解决了指针重复指向一块空间，又把已经创建好的s1对象和其中的内容都拷贝到了s2。

 总结：需要写析构函数的类，都需要写深拷贝的拷贝构造，如：Stack

不需要写析构函数的类，默认生成的浅拷贝的拷贝构造就可以用 。如：Date/MyQueue

---

5.运算符重载

1.为什么要重载运算符

为了让自定义类型可以使用 运算符

对于日期类，我们会经常用到，某个日期加多少天来得到另一个日期。

所以日期需要加减，也需要比较，那么使用+  =   -  ，在C++中，就需要运算符重载，与函数重载没有关系。

2.赋值运算符重载格式

返回值+operator+运算符 +（所需参数），参数个数就是参与运算符的参数个数

class Data
{
public:
	Data(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
 
bool operator==(Data& d1，Data& d2)
	{
		return d1._year == d2._year
			&& d1._month == d2._month
			&& d1._day == d2._day;
	}
 
int main()
{
	Data d1(2022, 10, 11);
	Data d2(2023, 1, 1);
    d1==d2;//可以显式调用 operator==(d1,d2);
	cout << (d1 == d2) << endl;
	cout << (d1 > d2) << endl;
}

1.定义运算符重载时，参数为引用的好处是，不需要调用拷贝函数，若是传值,参数为对象，则需要拷贝对象，调用拷贝函数。

2.定义在类外，需要将类的成员变量设置为公开，会造正麻烦，那么我们直接就定义到了类的内部。

3.若直接放入类的内部定义运算符重载，则会出现问题：

class Data
{
public:
	Data(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
 
      bool operator==(Data& d)
	{
		return this->_year == d2._year
			&& this->_month == d2._month
			&& this->_day == d2._day;
	}
 
private:
	int _year;
	int _month;
	int _day;
};
 
 
int main()
{
	Data d1(2022, 10, 11);
	Data d2(2023, 1, 1);
    d1==d2;//可以显式调用 operator==(d1,d2);
	cout << (d1 == d2) << endl;
	cout << (d1 > d2) << endl;
}

那为什么在类中，显示的是一个参数呢？
      bool operator==(Data& d)
    {
        return this->_year == d2._year
            && this->_month == d2._month
            && this->_day == d2._day;
    }

因为在类中定义的成员函数，都在公共区，自动会在参数中带一个this指针，为该类的创建的对象的地址。而且运算符重载限定了参数个数，则参数部分：bool operator==(Data& d)即为这样，实现则为 return this->_year == d2._year
                              && this->_month == d2._month
                              && this->_day == d2._day;

3.加法的实现

值得注意的一点是：加 +和 加等于+=是不一样的：

#define _CRT_SECURE_NO_WARNINGS 1
#include
using namespace std;
 
class Data
{
public:
	Data(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
 
	int Getmonthday(int year, int month)
	{
		int a[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
		if (month == 2 && (year % 4 == 0 && year % 100 != 0 || year % 4 == 0))
		{
			return 29;
		}
		else
			return a[month];
	}
 
	Data& operator+=(int day)
	{
		_day += day;
		while (_day> Getmonthday(this->_year, this->_month))
		{
				_day -= Getmonthday(this->_year, this->_month);
				_month++;
			if (_month > 12)
			{
				_month -= 12;
				_year++;
			}
		}
		cout << _year<<_month<<_day << endl;
		return *this;
	}
 
	Data operator+(int day)
	{
		Data ret(*this);
		ret +=day;
		return ret;
	}
 
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Data d1(2022, 10, 11);
	Data d2(2023, 1, 1);
	d1 + 100;
	d1 += 100;
	return 0;
}

还有其他运算符重载需要大家自己实现！

---

6.赋值运算符重载

1.赋值运算符重载格式

Date& operator=(const Date& d)
{
	if (this != &d)
	{
	_year = d._year;
	_month = d._month;
	_day = d._day;
	}
	return *this;
}
 
d1=d2;

赋值也是一样的，有两个参数，只不过第一个是隐藏的，赋值重载也是有顺序的：d1=d2；那么传参时，d1就是第一个参数，d2就是第二个参数。（像有双操作数的运算符，前后顺序就是参数顺序）

参数加const是因为原赋值对象不希望被改变，引用作为参数也可以避免拷贝；返回类型为引用是因为可以避免调用一次拷贝构造；遇到连等的情况：d1=d2=d3；链式访问（从右到左依次执行），d2=d3；会返回d2，再执行d1=d2;这就是有返回值的好处。

引用在传值传参和传值返回时，都可以减少拷贝构造的调用，节省时间空见。

返回值返回d1和d2都是可以的，只不过在返回d2时，前面返回类型就要加const，否则会扩大权限，所以为了更加方便，返回d1，即*this。

2.拷贝构造和赋值重载

d1=d2;就是把d2的值赋值给d1，那么是不是和拷贝构造也有相似之处呢？？

当然，但二者的区别是：拷贝构造：用已存在的类类型对象  创建新对象，赋值重载：已存在的两个对象之间的拷贝

他们都是会对内置类型进行处理，自定义类型会调用它的默认构造函数。

他们都是默认成员函数，自己不写，编译器就会默认生成。关键在于，编译器默认提供的，能不能符合我们的需求！

那么我们之前总结过，拷贝构造，当要调用析构函数时，就需要我们自己去写，赋值重载也是一样的。

举例说明：栈

如果使用编译器默认的赋值重载：

class Stack
	{
	public:
		Stack(int capacity = 4)
		{
			cout << "Stack(int capacity = )" <
	
			_a = (int*)malloc(sizeof(int)*capacity);
			if (_a == nullptr)
			{
				perror("malloc fail");
				exit(-1);
			}
	
			_top = 0;
			_capacity = capacity;
		}
		
		// st2(st1)
		Stack(const Stack& st)
		{
			cout << "Stack(const Stack& st)" << endl;
	
			_a = (int*)malloc(sizeof(int)*st._capacity);
			if (_a == nullptr)
			{
				perror("malloc fail");
				exit(-1);
			}
			memcpy(_a, st._a, sizeof(int)*st._top);
			_top = st._top;
			_capacity = st._capacity;
		}
	
	~Stack()
	{
		cout << "~Stack()" << endl;
 
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
 
	void Push(int x)
	{
		// ....
		// 扩容
		_a[_top++] = x;
	}
 
private:
	int* _a;
	int _top;
	int _capacity;
};
 
int main()
{
	Stack st1;
	st1.Push(1);
	Stack st2(10);
	st2.Push(1);
	st2.Push(2);
	st2.Push(3);
	st1 = st2;
	return 0;
}

 会发现和之前的拷贝构造出现的问题挺一样的，d1和d2的_a指向的空间是一样的，结果同一块空间还析构了两次，d1原本指向的空间，没人析构，造成内存泄露。当要调用析构函数时，就需要我们自己去写。

解决方案：既然是赋值，就得内存空间一样大，里面内容一样。

索性直接将d1内存空间直接释放，创建一个和d2一样大的内存空间，然后将里面内容拷贝进去。

也防止自己赋值自己，直接把自己的内存空间释放了。

代码如下：

Stack& operator=(const Stack& st)
	{
		if (this != &st)
		{
			free(_a);
			_a = (int*)malloc(sizeof(int) * st._capacity);
			if (_a == nullptr)
			{
				perror("malloc fail");
				exit(-1);
			}
			memcpy(_a, st._a, sizeof(int) * st._top);
			_top = st._top;
			_capacity = st._capacity;
		}
 
		return *this;
	}