类和对象（中）(2)

类和对象（中）(2)

前言

我们可以先回忆与总结一下，构造函数不写时编译器默认生成的行为是什么？

生成一个无参的构造函数（默认构造函数的一种），对于内置类型成员变量，我们不写时行为是不确定的（有的编译器初始化有的不初始化）；对于自定义类型成员变量会去调用它的默认构造函数。所以构造函数大多数情况都需要我们自己写，MyQueue这样的可以不写。我们怎么自己写呢？构造函数也就是初始化，怎么初始化是根据我们的需求来定的。

析构函数和构造函数是类似的。不写时编译器默认生成的行为是什么？也是内置类型不做处理，自定义类型会调用它默认的析构函数。所以像日期类这样没有资源需要清理，或者MyQueue（两个栈实现一个队列）这样的成员为自定义类型会调用默认析构的，都不需要我们写。栈里面有资源要释放这样的需要我们自己写。

自己实现的时候构造函数和析构函数的格式也是需要记忆的。

---

正文

拷贝构造函数

如果⼀个构造函数的第⼀个参数是自身类类型的引⽤，且任何额外的参数都有默认值，则此构造函数也叫做拷⻉构造函数，也就是说拷贝构造是⼀个特殊的构造函数。

拷贝构造的特点

1. 拷贝构造函数是构造函数的⼀个重载。（符合构造函数的特点）

2. 拷贝构造函数的第⼀个参数必须是自身类类型对象的引用（自己类型来初始化自己），使⽤传值⽅式编译器直接报错，因为语法逻辑上会引发无穷递归调⽤。

   拷贝构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引⽤，后⾯的参数必须有缺省值。

   Date(const Date& d)
   {
   	_year = d._year;
   	_month = d._month;
   	_day = d._day;
   }
   

   因为是构造函数，可以看到函数名和类名相同，且没有返回值；拷贝构造函数的第⼀个参数是自身类类型对象的引用。

3. C++规定⾃定义类型对象进⾏拷贝⾏为必须调⽤拷贝构造，所以这⾥⾃定义类型传值传参和传值返回都会调⽤拷贝构造完成。

   根据上面所说的C++规定，如果拷贝构造函数的第一个参数不是引用而是自身类型，在语法上每次要调用拷贝构造就要先传值传参，传值传参是一种拷贝，又形成一个新的拷贝构造，就形成无穷递归。

   

   所以使用引用的话就能解决这个问题。

   同时加了引用后，就建议把const也加上（除非要改变外面的实参）。这样可以保护形参不被改变。

   所以以后对于自定义类型，不建议用传值传参，因为传值传参要调用拷贝构造。

   void Func1(const Date& d)//写成这样比较好
   {
       cout<<&d<<endl;
   }
   

4. 若未显式定义拷贝构造，编译器会⾃动⽣成拷贝构造函数。⾃动⽣成的拷⻉构造对内置类型成员变量（注意构造函数和析构函数对内置类型是不作处理）会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷贝)（就像memcpy)，对⾃定义类型成员变量会调⽤他的拷贝构造（和之前一样）。

   （注意和之前最大不同点在于内置类型它也管）

所以我们发现日期类无需写拷贝构造

到这里，似乎拷贝构造不用我们去管，毕竟内置类型和自定义类型都有处理，但其实不是这样。

5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷贝构造就可以完 成需要的拷贝，所以不需要我们显⽰实现拷贝构造。像Stack这样的类，虽然也都是内置类型，但 是_a指向了资源，编译器⾃动⽣成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。

   比如我们现在

   int main()
   {
   	Stack st1;
   	st1.Push(1);
   	st1.Push(2);
   	// Stack不显式实现拷贝构造，用自动生成的拷贝构造完成浅拷贝
   	// 会导致st1和st2里面的_a指针指向同一块资源，析构时会析构两次，程序崩溃
   	Stack st2(st1);
   
   	return 0;
   }
   

   

   应该这样写：

    //st2(st1)
   	Stack(const Stack& st)
   	{
   		// 需要对_a指向资源创建同样大的资源再拷贝值
   		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
   		if (nullptr == _a)
   		{
   			perror("malloc申请空间失败!!!");
   			return;
   		}
   		memcpy(_a, st._a, sizeof(STDataType) * st._top);
   		_top = st._top;
   		_capacity = st._capacity;
   	}
   

   传值传参为什么要调用拷贝构造？

   void func(Stack st)
   {
       
   }
   int main()
   {
       Stack st1;
       st1.Push(1);
       st1.Push(2);
       
       func(st1);
       
       return 0;
   }
   

   在这段代码中，假设这是C语言，其实我们将st1传值传参后，指向同一块资源，里面改变其实也会影响外面。st去Destroy，回到main后st1又Destroy，程序崩溃。

   C++中设计出自定义类型传值传参要拷贝构造其实是为了补C语言的坑。

   这段代码在C++中，由于传值传参有了拷贝构造，且我们有了深拷贝，st的改变就不会影响st1。

   同时这也警示，自定义类型用传值传参不好，拷贝构造的代价很大。所以尽量用引用，不改变就加上const。

   像MyQueue（两个栈实现一个队列）这样的类型内部主要是⾃定义类型 Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显式实现 MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧，如果⼀个类显式实现了析构并释放资源，那么他就需要显式写拷⻉构造，否则就不需要。

   补充：

   Stack st2(st1);
   Stack st3 = st1;//这样写也是调用拷贝构造
   

6. 传值返回会产⽣⼀个临时对象，调⽤拷⻉构造，传值引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷贝。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少拷贝，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。

运算符重载

在上一篇文章中已经讲到了一些运算符重载的内容但没有讲完，本文接着讲。

• 当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编译报错。

• 运算符重载是具有特殊名字的函数，他的名字是由operator和后⾯要定义的运算符共同构成。和其他函数⼀样，它也具有其返回类型和参数列表以及函数体。

• 重载运算符函数的参数个数和该运算符作⽤的运算对象数量⼀样多。⼀元运算符有⼀个参数，二元 运算符有两个参数，二元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第二个参数。

• 如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数⽐运算对象少⼀个。

• 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。

• 不能通过连接语法中没有的符号来创建新的操作符：⽐如operator@。

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

(.*这个运算符在做成员函数的回调时会用到，但是很这样做)

• 重载操作符⾄少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义，如： int operator+(int x, int y)

• ⼀个类需要重载哪些运算符，是看哪些运算符重载后有意义，⽐如Date类重载operator-就有意义，但是重载operator+就没有意义。

• 重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，⽆法很好的区分。 C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，⽅便区分。

• 重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位 置，第⼀个形参位置是左侧运算对象，调⽤时就变成了对象<

赋值运算符重载

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

易混淆，要注意

Date d1(2024,8,7);
Date d2(2024,8,8);

//赋值重载拷贝
d1 = d2;

//拷贝构造
Date d3(d2);
Date d4 = d2;

赋值运算符重载的特点

1. 赋值运算符重载是⼀个运算符重载，规定必须重载为成员函数（不能重载为全局的）。赋值运算重载的参数建议写成 const当前类类型引⽤（但是写成传值传参也不会无穷递归了），否则会传值传参会有拷⻉。

2. 有返回值，且建议写成当前类类型引⽤，引⽤返回可以提高效率，有返回值目的是为了支持连续赋值场景。

   //d3=d1
   Date operator = (const Date& d)
   {
       _year = d._year;
       _month=d.month;
       _day=d._day;
       
       return *this;
   }
   //但是传值返回会有拷贝，所以这样写更好
   Date& operator = (const Date& d)
   {
       _year = d._year;
       _month=d.month;
       _day=d._day;
       
       return *this;
   }
   

3. 没有显式实现时，编译器会自动生成⼀个默认赋值运算符重载，默认赋值运算符重载行为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)，对自定义类型成员变量会调用他的赋值重载函数。

4. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们显⽰实现赋值运算符重载。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的赋值运算符重载完成的值拷贝/浅拷贝不符合我 们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的赋值运算符重载会调用Stack的赋值运算符重载， 也不需要我们显式实现MyQueue的赋值运算符重载。这里还有⼀个⼩技巧，如果⼀个类显式实现了析构并释放资源，那么他就需要显式写赋值运算符重载，否则就不需要。

本文到此结束。