类和对象（中）

1. 构造函数

1.1定义

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使⽤的局部对象是栈帧创建时，空间就开好了)，而是对象实例化时初始化对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数自动调用的特点就完美的替代的了Init。简而言之，类比我们之前写的init函数。

1.2构造函数的特点

1. 函数名与类名相同。
2. 无返回值。 (返回值啥都不需要给，也不需要写void，C++规定如此)
3. 对象实例化时系统会自动调用对应的构造函数。
4. 构造函数可以重载。
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
6. 无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有一个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。
   注意：很多人会认为默认构造函数是编译器默认生成那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，总结一下就是不传实参就可以调用的构造就叫默认构造。
7. 我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决，初始化列表，我们下个章节再细细讲解。

注：1.内置类型：int / double / char...../指针

自定义类型：class/struct/union....

2.只有类里面全是自定义函数，且里面的自定义类型有默认构造函数，只有在这种情况下，才 不用写构造函数。（下文会解释）

1.3默认构造函数

在C++中，默认构造函数是一种特殊的构造函数，它没有参数。如果一个类没有显式地定义任何构造函数，编译器会为该类自动生成一个默认构造函数。默认构造函数用于创建对象时初始化对象的成员变量。

#include<iostream>
using namespace std;
class Date
{
public:
	// 1.⽆参构造函数
	//Date()
	//{
	//	_year = 1;
	//	_month = 1;
	//	_day = 1;
	//}
	//2.带参构造函数
	//Date(int year, int month, int day)
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
	//3.全缺省构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

//函数声明
//Date func();
//Date func(int, int, int);

int main()
{
	// 如果留下三个构造中的第⼆个带参构造，第⼀个和第三个注释掉 
	// 编译报错：error C2512: "Date": 没有合适的默认构造函数可⽤
	Date d1;     // 调⽤默认构造函数
	Date d2(2024, 11, 14);
	// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法区分这⾥是函数声明 
            还是实例化对象 (对比第37行和49行）
	// warning C4930: "Date d3(void)": 未调⽤原型函数(是否是有意⽤变量定义的?)
	Date d3(2024, 11);
	//Date d4();            //会误以为是声明，导致后面没法打印
	d1.print();
	d2.print();
	d3.print();
	//d4.print();


	return 0;
}

**注：**若我们写了一个带参构造的，会出现以下报错：

所以我们第二个构造函数要注释掉，不能这样写。

但是，还有一个问题，当我们把第二个注释掉后，保留1和3时，编译器还会报错：

1>C:\Users\21098\Desktop\c++\test1114\test1114\test.cpp(45,7): error C2668: "Date::Date": 对重载函数的调用不明确

这是因为编译器此时不知道调用哪个，举个例子，如果想要调用一个无参构造，第一个函数能调用，第三个函数也能调用，所以就不知道调用哪个了，就会产生混淆，从而报错！

故此，个人觉得写一个全缺省的就好，多功能的，省事（个人感觉）

我们在看一下上述这个点：

2.只有类里面全是自定义函数，且里面的自定义类型有默认构造函数，只有在这种情况下，才不用写构造函数。

不妨来举个例子：

#include<iostream>
using namespace std;
typedef int stdatatype;
class stack
{
public:
	stack(int n = 4)
	{
		_a = (stdatatype*)malloc(sizeof(stdatatype) * n);
		if (nullptr == _a)
		{
			perror("malloc fail!");
			return;
		}
		_capacity = n;
		_top = 0;
	}
private:
	stdatatype* _a;
	size_t _capacity;
	size_t _top;
};
// 两个Stack实现队列
class myqueue
{
public:
	//编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
private:
	stack pushst;
	stack popst;
};
int main()
{
	myqueue mq;
	return 0;
}

2.析构函数

2.1定义

C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。析构函数的功能类比我们之前Stack实现的Destroy功能，而像Date没有Destroy，其实就是没有资源需要释放，也就是说 只有经过动态开辟的才需要写析构，如上述例子中，日期类是不需要写析构的，栈需要写！

2.2析构函数的特点：

1. 析构函数名是在类名前加上字符 ~。

2. 无参数无返回值。 (这里跟构造类似，也不需要加void)

3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。

4. 对象生命周期结束时，系统会自动调用析构函数。

5. 跟构造函数类似，如果我们不写，编译器自动生成的析构函数对内置类型成员不做处理，自定类型成员会调用他的析构函数。

6. 我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。

7. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，如Date；如果默认生成的析构就可以用，也就不需要显示写析构，如MyQueue；但是有资源申请时，一定要自己写析构，否则会造成资源泄漏，如Stack。

8. 一个局部域的多个对象，C++规定后定义的先析构。

   #include<iostream>
   using namespace std;
   typedef int stdatatype;
   class stack
   {
   public:
   stack(int n = 4)
   {
   _a = (stdatatype*)malloc(sizeof(stdatatype) * n);
   if (nullptr == _a)
   {
   perror("malloc fail!");
   return;
   }
   _capacity = n;
   _top = 0;
   }
   ~stack()
   {
   free(_a);
   _a = nullptr;
   _top = _capacity = 0;
   }
   private:
   stdatatype* _a;
   size_t _capacity;
   size_t _top;
   };
   // 两个Stack实现队列
   class myqueue
   {
   // 不需要写构造，默认生成就可以用
   // 不需要写析构，默认生成就可以用
   public:
   //编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
   ~myqueue()
   {
   cout << "~myqueue()" << endl;
   }
   private:
   stack pushst;
   stack popst;
   };
   int main()
   {
   myqueue mq;
   return 0;
   }

3. 拷贝构造函数

3.1定义

在C++中，拷贝构造函数是一种特殊的构造函数，它用于创建一个对象作为另一个同类型对象的副本。当你需要将一个对象初始化为另一个对象的副本时，就会调用拷贝构造函数。如果程序员没有提供自定义的拷贝构造函数，编译器会生成一个默认的拷贝构造函数。如果一个构造函数的第一个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造是一个特殊的构造函数。

3.2拷贝构造的特点：

1. 参数类型 ：拷贝构造函数接受一个单一参数，该参数是对同类型对象的常量引用（const）。这防止了在拷贝构造函数调用过程中对原始对象的修改。

2. 参数数量：拷贝构造函数只能有一个参数，即使它是一个参数列表（即只有一个参数）。

3. 默认行为：如果用户没有提供自定义的拷贝构造函数，编译器会生成一个默认的拷贝构造函数，该函数执行成员初始化列表中的浅拷贝。

4. 调用时机：

   • 当一个对象以另一个同类型对象初始化时。
   • 当函数返回一个对象时（返回值优化可能会阻止拷贝构造函数的调用）。
   • 当对象作为参数传递给函数时，如果参数是通过值传递的。

5. 常量对象：如果一个对象被声明为常量，那么只能调用该对象的常量成员函数。因此，如果一个常量对象需要被拷贝，只能调用拷贝构造函数。

6. 深拷贝与浅拷贝：

   • 浅拷贝：简单地复制成员变量的值，如果成员是指针，则只复制指针的值，不复制指针指向的数据。
   • 深拷贝：为指针成员分配新的内存，并复制指针指向的数据，确保新对象有自己的数据副本。

3.3代码实现

我们先基本实现一下，感受一下：

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//Date d2(d1);             this  就是  d2,d   就是d1
	Date(const	Date& d)
	{
		this->_year = d._year;      //通常情况下，我们省略前面的this指针
		_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, 11, 14);
	Date d2(d1);
	return 0;
}

调试观察一下：发现我们的d2已经成功拷贝了d1！

此时，细心的人会会有疑问，可不可以把引用换成指针呢？我们来试一下：

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// Date d3(&d1);
	Date(Date* d)
	{
		cout << "Date(Date& d)" << endl;
		_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, 11, 14);
	Date d2(d1);
	Date d3(&d1);
	d1.print();
	d2.print();
	d3.print();
	return 0;
}

结果仍然是对的，但是这个不能称之为拷贝构造了，只能称之为构造！

4. 赋值运算符重载

4.1 运算符重载

• 当运算符被用于类类型的对象时，C++语言允许我们通过运算符重载的形式指定新的含义。C++归定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
• 运算符重载是具有特名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数一样，它也具有其返回类型和参数列表以及函数体。
• 重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。（一个运算符或者运算数就是一元，以此类推）
• 如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个。
• 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。
• 不能通过连接语法中没有的符号来创建新的操作符：比如operator@。
• .* :: sizeof ?:（三目操作符） . 注意以上5个运算符不能重载。
• 重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，如： int
operator+(int x, int y)
• 重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。
C++规定，后置++重载时，增加一个int形参，跟前置++构成函数重载，方便区分。
• 重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第一个形参位
置，第一个形参位置是左侧运算对象，调用时就变成了 对象<<cout，不符合使用习惯和可读性。
重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第二个形参位置当类类型对象

现在我们来感受一下

#include<iostream> 
using namespace std;
class Date
	{
	public:
		Date(int year = 1, int month = 1, int day = 1)
		{
			_year = year;
			_month = month;
			_day = day;
		}
		void print()
		{
			cout << _year << "-" << _month << "-" << _day << endl;
		}
	
	//private:
		int _year;
		int _month;
		int _day;
	};
bool operator==(const Date& x1, const Date& x2)
{
	return x1._year == x2._year
		&& x1._month == x2._month
		&& x1._day == x2._day;
}
int operator-(const Date& x1, const Date& x2)
{

	return 0;
}
int main()
{
	Date d1(2024, 11, 14);
	Date d2(2024, 11, 11);
	//bool ret0 = operator==(d1, d2);    这样也可以，但是我们不喜欢这样写
	bool ret1 = d1 == d2;
	cout << ret1 << endl;
	return 0;
}

我们解释一下 .* 的含义，并将其与普通函数指针类型对比：

#include<iostream> 
using namespace std;
// 编译报错："operator +"必须⾄少有⼀个类类型的形参 
//int operator+(int x, int y) 
//{
//	return x - y; 
//}
class A
{
public:
	void func()
	{
		cout << "A::func()" << endl;
	}
};

typedef void(A::* PF1)();   //成员函数指针类型
typedef void(*PF2)();	//函数指针类型
void func2()
{
	cout << "func2()" << endl;
}
int main()
{
	// C++规定成员函数要加&才能取到函数指针
	PF1 pf1 = &A::func;
	A obj;//定义ob类对象temp
	(obj.*pf1)();           //可以简单理解为先将pf1解引用，再去寻找
	PF2 pf2 = func2;
	(*pf2)();
	return 0;
}

结果如下：

4.2 赋值运算符重载

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

4.2.1赋值运算符重载的特点：

1. 赋值运算符重载是一个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成
   const 当前类类型引用，否则会传值传参会有拷贝
2. 有返回值，且 建议写成当前类类型引用 ，引用返回可以提高效率，有返回值目的是为了支持连续赋值场景。
3. 没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为跟默认构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。
4. 类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们实现赋值运算符重载。
   像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。
   像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的赋值运算符重载会调⽤Stack的赋值运算符重载，也不需要我们实现MyQueue的赋值运算符重载。
   总之而言之：如果一个类显示实现了析构并释放资源，那么他就需要显示写赋值运算符重载，否则就不需要。

我们看一下代码：

#include<iostream>
using namespace std;
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;
    }
	// 传引⽤返回减少拷⻉ 
	// d1 = d2;
	Date& operator=(const Date& d)
	{
		//this  就是指向d1的指针，d   是d2的别名（引用）
		// 不要检查⾃⼰给⾃⼰赋值的情况
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		// d1 = d2表达式的返回对象应该为d1，也就是*this
		return *this;           //出了作用域，*this还在，故可以用引用返回，否之不能
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 11, 16);
	d1.print();
	Date d2(d1);
	d2.print();
	Date d3(2024, 11, 14);
	d1 = d3;
	d1.print();
	d3.print();
	// 需要注意这⾥是拷⻉构造，不是赋值重载 
	// 请牢牢记住赋值重载完成两个已经存在的对象直接的拷⻉赋值 
	// ⽽拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象
	Date d4 = d1;
	return 0;
}

运行结果附上：