深圳网站建设服,网站备案提交,如何建网站老鱼网,浙江建设报名网站C学习笔记---005 C知识类和对象篇1、类的6个默认成员函数2、构造函数2.1、构造函数的特性2.2、内置类型和自定义类型2.3、什么是默认构造函数#xff1f; 3、析构函数3.1、什么是析构函数#xff1f;3.2、析构函数的特性3.3、析构函数的释放顺序 4、拷贝构造函数4.1、什么是拷… C学习笔记---005 C知识类和对象篇1、类的6个默认成员函数2、构造函数2.1、构造函数的特性2.2、内置类型和自定义类型2.3、什么是默认构造函数 3、析构函数3.1、什么是析构函数3.2、析构函数的特性3.3、析构函数的释放顺序 4、拷贝构造函数4.1、什么是拷贝构造函数4.2、拷贝构造函数的特性4.3、拷贝构造函数典型调用场景4.4、理解传值传参和传引用传参4.5、const正确的适用4.6、拷贝构造的默认处理4.7、拷贝构造浅拷贝的无脑拷贝问题 5、操作符重载关键字operator5.1、关键字operator5.2、私有限定符情况5.3、了解‘.*’操作符 6、赋值运算符重载6.1、 赋值运算符重载6.2、 拷贝构造函数与赋值运算符重载的区别 7、类的6个默认成员函数总结 C知识类和对象篇
前言 前面篇章学习了C对于C语言的语法优化接下来继续学习C的类和对象中类的6个默认成员函数的知识。 /知识点汇总/
1、类的6个默认成员函数
如果一个类中什么成员都没有简称为空类。 空类中真的什么都没有吗并不是任何类在什么都不写时编译器会自动生成以下6个默认成员函数。 默认成员函数用户没有显式实现编译器会生成的成员函数称为默认成员函数。
class A{ };1.初始化和清理 初始化构造函数主要完成初始化工作 清理析构函数主要完成释放/清理工作。 2.拷贝和复制 拷贝拷贝函数使用同类对象初始化创建对象 赋值重载主要把一个对象赋值给另一个对象。 3.取地址和重载相对于前4个做个了解 主要是普通对象和const对象取地址这两个很少会自己实现由编译器实现。 2、构造函数
概念构造函数是一个特殊的成员函数名字与类名相同,创建类类型对象时由编译器自动调用以保证每个数据成员都有 一个合适的初始值并且在对象整个生命周期内只调用一次。
2.1、构造函数的特性
特性 构造函数是特殊的成员函数需要注意的是构造函数虽然名称叫构造但是构造函数的主要任务并不是开空间创建对象而是初始化对象。 其特征如下 函数名与类名相同。无返回值。(不是void,直接不用写)对象实例化时编译器自动调用对应的构造函数。构造函数可以重载。如果类中没有显式定义构造函数则C编译器会自动生成一个无参的默认构造函数一旦用户显式定义编译器将不再生成。 #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;}//构造函数支持缺省参数语法上可以与无参的构造函数重载但是编译会有歧义所以可以重载但有歧义。//编译报错显示对重载函数调用不明确。//Date(int year 1, int month 2, int day 3)//{// _year year;// _month month;// _day day;//}void Print(){cout _year - _month - _day endl;}
private:int _year;int _month;int _day;
};
int main()
{Date d1;d1.Print();//构造函数特殊的函数对象后面跟的参数但是参数不能为空因为需要区分无参函数。Date d2(2024,1,27);d2.Print();return 0;
}2.2、内置类型和自定义类型
默认成员函数之一构造函数我们不写编译器就会生成一个它并不会对内置类型执行什么操作由编译器不同也有不同会对自定义类型初始化0操作。 C分为内置类型/基本类型即语言自身定义的类型int/char/doubl…还有自定义类型即struct/class/enum… 默认生成的构造函数对于内置类型不做处理自定义类型会去调用他的默认构造。
#include iostream
using namespace std;
class A
{
public://构造函数对自定义类型的默认处理A(){cout print_A() endl;_a 0;cout _a endl;_a 2;}
private:int _a;
};class Date
{
public://构造函数不写构造函数随机值Date(){_year 1;_month 1;_day 1;}void Print(){cout _year - _month - _day endl;}
private://这里是声明不是初始化给的是缺省值int _year 1;int _month 1;int _day;A _a;
};
int main()
{Date d1;d1.Print();return 0;
}所以具体还是需要分析一个类型成员是否需要初始化需求 需要就写构造函数不需要就交给编译器执行默认动作。 结论一般情况下都是自己写更适用。如果没写构造函数编译器才会生成否则一旦写了编译器就不会写了。
#include iostream
using namespace std;
class stack
{
public:stack(){cout Stack_Init()... endl;}
};
class MyQueue
{
private:stack str1;stack str2;
};
int main()
{//构造函数适用于自定义类型MyQueue q;return 0;
}2.3、什么是默认构造函数
默认的构造函数不完全等于编译器生成的构造函数还包括无参的和全缺省的构造函数。 一般构造函数只需要写一个否则存在编译歧义。 所以什么是默认构造函数 答1.无参构造函数 2.全缺省构造函数 3.没写构造而由编译器默认生成的构造函数 简述不需要传参就可以调用的构造函数都可以叫默认构造函数。 使用构造函数通常满足三个条件 1.条件1因为我们写了与类同名且无返回类型的构造函数所以编译器就不会写了。 2.条件2但是我们自己写的额构造函数不成立因为构造函数有2中除了编译器生成的以外就是无参和全缺省所以报错没有合适的默认构造函数可用。 3.条件33种构造函数又只能写一种推荐写全缺省否则编译会与其它2种构造函数存在歧义。 #include iostream
using namespace std;
class Date
{
public://构造函数的条件不成立所以报错Date(int year, int month, int day){_year year;_month month;_day day;}//无参的构造函数Date(){_year 2024;_month 1;_day 27;}void Print(){cout _year - _month - _day endl;}
private://这里是声明不是初始化给的是缺省值//注意是因为C11 中针对内置类型成员不初始化的缺陷又打了补丁//即内置类型成员变量在类中声明时可以给默认值。不等于初始化int _year 1;int _month 1;int _day;
};
int main()
{//构造函数的条件不成立所以报错//1.条件1因为我们写了与类同名且无返回类型的构造函数所以编译器就不会写了。//2.条件2但是我们自己写的额构造函数不成立因为构造函数有2中除了编译器生成的以外就是无参和全缺省所以报错没有合适的默认构造函数可用。//3.条件33种构造函数又只能写一种推荐写全缺省否则编译会与其它2种构造函数存在歧义。Date d1;d1.Print();//构造函数支持函数重载直接对象传参Date d2(2024, 2, 11);d2.Print();return 0;
}3、析构函数
主要完成的清理和释放资源常用于malloc等开辟的空间释放
3.1、什么是析构函数
概念 与构造函数功能相反析构函数不是完成对对象本身的销毁局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数完成对象中资源的清理工作。
#include iostream
using namespace std;
class Date
{
public://无参的构造函数Date(){_year 2024;_month 1;_day 27;}void Print(){cout _year - _month - _day endl;}//析构函数的格式,一般用户自定义类型比如栈...~Date(){//验证编译器确实会在 对象生命周期结束时默认调用执行cout ~Date endl;}
private:int _year 1;int _month 1;int _day;
};
int main()
{Date d1;d1.Print();return 0;
}3.2、析构函数的特性 析构函数是特殊的成员函数其特征如下 析构函数名是在类名前加上字符 ~。无参数无返回值类型。一个类只能有一个析构函数。若未显式定义系统会自动生成默认的析构函数。注意析构函数不能重载对象生命周期结束时C编译系统系统自动调用析构函数。 #include iostream
#include assert.h
using namespace std;typedef int DataType;class Date
{
public://无参的构造函数Date(){_year 2024;_month 1;_day 27;}void Print(){cout _year - _month - _day endl;}//析构函数的格式,一般用户自定义类型比如栈...~Date(){//验证编译器确实会在 对象生命周期结束时默认调用执行cout ~Date endl;}
private:int _year;int _month;int _day;
};class Stack
{
public:Stack(int n 4){//放个打印表示默认执行了的cout Stack endl;_array (DataType*)malloc(sizeof(DataType) * n);if (_array nullptr){perror(malloc fail);return;}_size 0;_capacity n;}void PushBack(DataType data){//扩容if (_size _capacity){int newcapacity _capacity 0 ? 4 : _capacity * 2;DataType* tmp (DataType*)realloc(_array, sizeof(DataType) * newcapacity);if (tmp nullptr){perror(realloc fail);return;}_array tmp;_capacity newcapacity;}_array[_size] data;_size;}DataType GetTop(){return _array[_size-1];}void PopBack(){_size--;}//DataType GetPopVal()//{// return _array[_size-1];//}bool Empty(){return _size 0;}~Stack(){//放个打印表示默认执行了的cout ~Stack endl;if (_array){free(_array);_array nullptr;_size 0;_capacity 0;}}
private:DataType* _array;int _size;int _capacity;
};int main()
{Date d1;d1.Print();//Stack s1(4);Stack s1;s1.PushBack(1);s1.PushBack(2);s1.PushBack(3);while (!s1.Empty()){cout s1.GetTop() endl;s1.PopBack();}return 0;
}小结 1.可以发现先打印的 ~Stack ,再打印的 ~Date显然先创建的d1对象后创建的s1对象 说明析构满足栈的特性。先进后出/后进先出。即先创建的后析构。 2.如果类中没有申请资源时析构函数可以不写直接使用编译器生成的默认析构函数比如Date类有资源申请时一定要写否则会造成资源泄漏比如Stack类。 3.编译器默认生成的析构与构造函数类似内置类型不做处理自定义类型则调用它的写的析构适合Queue,stack 3.3、析构函数的释放顺序
析构函数的释放顺序 局部对象后定义的先析构–》局部静态–》全局对象后定义的先析构 补充虽然编译器对于构造函数和析构函数对自定义函数处理但自定义类型的底层还是内置类型的嵌套。 #include iostream
using namespace std;class Date
{
public://全缺省的构造函数Date(int year){_year year;}//析构函数~Date(){cout ~Date() _year endl;}
private:int _year;int _month;int _day;
};
Date d6(6);
static Date d7(7);void Test()
{Date d4(4);static Date d5(5);
}
int main()
{Date d1(1);Date d2(2);static Date d3(3);Test();return 0;
}4、拷贝构造函数
4.1、什么是拷贝构造函数 拷贝构造函数概念只有单个形参该形参是对本类类型对象的引用(一般常用const修饰)在用已存在的类类型对象创建新对象时由编译器自动调用。 4.2、拷贝构造函数的特性 拷贝构造函数也是特殊的成员函数其特征如下 拷贝构造函数是构造函数的一个重载形式。拷贝构造函数的参数只有一个且必须是类类型对象的引用使用传值方式编译器直接报错因为会引发无穷递归调用。若未显式定义编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝这种拷贝叫做浅拷贝或者值拷贝。 注意在编译器生成的默认拷贝构造函数中内置类型是按照字节方式直接拷贝的而自定义类型是调用其拷贝构造函数完成拷贝的。编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了还需要自己显式实现吗当然像日期类这样的类是没必要的。所以是根据实际的应用场景决定。 注意类中如果没有涉及资源申请时拷贝构造函数是否写都可以一旦涉及到资源申请时则拷贝构造函数是一定要写的否则就是浅拷贝。 4.3、拷贝构造函数典型调用场景 1.使用已存在对象创建新对象 2.函数参数类型为类类型对象 3.函数返回值类型为类类型对象 #include iostream
using namespace std;class Date
{
public://默认的成员函数都别忘了隐式的this指针参数//全省参数构造函数Date(int year 1, int month 1, int day 1){_year year;_month month;_day day;}//拷贝构造函数的基本格式//const目的理解为控制权限/权限保护Date(const Date d){_year d._year;_month d._month;_day d._day;}void Print(){cout _year - _month - _day endl;}
private:int _year 1;int _month 1;int _day 1;
};int main()
{Date d1(2024, 1, 28);d1.Print();//拷贝构造Date d2(d1);d2.Print();return 0;
}4.4、理解传值传参和传引用传参 C规定执行自定义类型都会调用拷贝构造执行了拷贝构造之后再进入自定义类型执行。 #include iostream
using namespace std;class Date
{
public://默认的成员函数都别忘了隐式的this指针参数//全省参数构造函数Date(int year 1, int month 1, int day 1){_year year;_month month;_day day;}//拷贝构造函数的基本格式//const目的理解为控制权限/权限保护Date(const Date d){_year d._year;_month d._month;_day d._day;}void Print(){cout _year - _month - _day endl;}
private:int _year 1;int _month 1;int _day 1;
};
//传值传参
//由于C规定的这个特性就可能会导致造成“死递归”的循环去调用拷贝构造。
//所以通常会结合const修饰参数的权限/属性
void func1(Date d)
{}
//传引用传参引用不会调用拷贝构造它是别名直接就可以操作参数。
void func2(Date d)
{}
int main()
{Date d1(2024, 1, 28);d1.Print();//拷贝构造Date d2(d1);d2.Print();//C规定自定义类型都会先调用拷贝构造//调用拷贝构造之前会先传参又因为是传值传参就会形成新的拷贝构造依次类推的陷入死循环func1(d1);func2(d2);return 0;
}4.5、const正确的适用
const正确的适用有利于保护数据/权限访问/参数检查
#include iostream
using namespace std;class Date
{
public://默认的成员函数都别忘了隐式的this指针参数//全省参数构造函数Date(int year 1, int month 1, int day 1){_year year;_month month;_day day;}//拷贝构造函数的基本格式//Date(Date d)易错//const目的理解为控制权限/权限保护Date(const Date d){//const保护参数是否写法的检查//d._year this-_year;_year d._year;_month d._month;_day d._day;}void Print(){cout _year - _month - _day endl;}
private:int _year 1;int _month 1;int _day 1;
};int main()
{Date d1(2024, 1, 28);d1.Print();//拷贝构造Date d2(d1);d2.Print();Date d3(d2);d3.Print();return 0;
}4.6、拷贝构造的默认处理 拷贝构造会对自定义类型进行默认处理 1.若没有显式定义的拷贝构造函数那么编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按照内置类型成员按照内存存储的额字节依次完成拷贝这种叫作浅拷贝。或叫值拷贝。 2.另外对于自定义的类型的拷贝函数称为深拷贝/引用拷贝。 拷贝构造函数的参数只能有一个并且必须是类类型对象的引用因为传值是死递归直接报错。 #include iostream
using namespace std;class Time
{
public://强制编译器生成构造函数因为后面写了拷贝构造函数所以需要自己写//但这里只是为了验证拷贝构造函数的深拷贝所以构造函数就没什么意义,//就使用强制默认构造defaultTime() default;//拷贝构造函数Time(const Time t){//打印验证cout Time() endl;_hour t._hour;_minute t._minute;_second t._second;}void Print(){cout _hour - _minute - _second endl;}
private:int _hour 1;int _minute 1;int _second 1;
};class Date
{
public:Date(int year 1, int month 1, int day 1){_year year;_month month;_day day;}//Date(const Date d)//{// _year d._year;// _month d._month;// _day d._day;//}void Print(){cout _year - _month - _day endl;}
private:int _year 1;int _month 1;int _day 1;//验证自定义类型Time _t;
};int main()
{Date d1(2024, 1, 28);d1.Print();//Time t1;//t1.Print();//拷贝构造Date d2(d1);d2.Print();Date d3(d2);d3.Print();return 0;
}小结 若未显式定义编译器会自动生成默认的拷贝构造传值拷贝会调用拷贝构造函数称为浅拷贝 对自定义类型的成员则调用它自己的拷贝构造称为深拷贝。 补充 为了提高程序效率一般对象传参时尽量使用引用类型返回时根据实际场景能用引用尽量使用引用。
4.7、拷贝构造浅拷贝的无脑拷贝问题 那么既然编译器不管内置类型还是自定义类型都会帮我们执行拷贝工作那么还需要我们自己写 答当然编译器不可能完成一些复杂的逻辑和操作所以遇到栈等开辟额外空间的操作时需要我们自己注意完善。 #include iostream
using namespace std;
typedef int DataType;
class Stack
{
public:Stack(size_t capacity 10){_array (DataType*)malloc(capacity * sizeof(DataType));if (nullptr _array){perror(malloc申请空间失败);return;}_size 0;_capacity capacity;}void Push(const DataType data){// CheckCapacity();_array[_size] data;_size;}//深拷贝处理//解决办法就是开辟另一块同样大小的空间进行相关的操作Stack(const Stack s){DataType* tmp (DataType*)malloc(s._capacity * sizeof(DataType));if (nullptr tmp){perror(malloc申请空间失败);return;}//拷贝数据 --sizememcpy(tmp, s._array, sizeof(DataType) * s._size);_array tmp;_size s._size;_capacity s._capacity;}~Stack(){if (_array){free(_array);_array nullptr;_capacity 0;_size 0;}}
private:DataType* _array;size_t _size;size_t _capacity;
};
int main()
{Stack s1;s1.Push(1);s1.Push(2);s1.Push(3);s1.Push(4);//拷贝构造函数Stack s2(s1);return 0;
}这段代码的核心问题在于拷贝构造函数会连同数组的地址一同无脑的拷贝所以在程旭执行结束执行free释放时由于两个数组地址指向了同一块地址空间那么释放掉其中一个指针那么另外一个再去释放就造成了同一块区域空间的重复释放的问题。 解决办法就是我们自己编写深拷贝处理正确的数组指针正确的释放。 小结一般来说浅拷贝不适用于malloc开辟空间这种情况。所以一般交给深拷贝处理。
5、操作符重载关键字operator
5.1、关键字operator
C为了增强代码的可读性引入了运算符重载运算符重载是具有特殊函数名的函数也具有其返回值类型函数名字以及参数列表其返回值类型与参数列表与普通的函数类似。 操作符重载为关键字operator后面接需要重载的运算符符号。 函数原型返回值类型 operator操作符(参数列表) 注意 1.不能通过连接其他符号来创建新的操作符比如operator。 2.重载操作符必须有一个类类型参数。 3.用于内置类型的运算符其含义不能改变 例如内置的整型 不能改变其含义作为类成员函数重载时其形参看起来比操作数数目少1因为成员函数的第一个参数为隐藏的this。 4.注意‘.*’ ‘::’ ‘sizeof’ ‘?:’ ‘.’ 注意以上5个运算符不能重载。 #include iostream
using namespace std;class Date
{
public:Date(int year 1900, int month 1, int day 1){_year year;_month month;_day day;}
//private:int _year;int _month;int _day;
};//bool DateEqual(const Date x, const Date y)
//运算符重载operator 运算符
bool operator(const Date x, const Date y)
{return x._year y._year x._month y._month x._day y._day;
}
//日期不能整体比较
//2024 1 28
//2024 1 27
//2024 2 26//bool DateLess(const Date x, const Date y)
//运算符重载operator 运算符
bool operator(const Date x, const Date y)
{if (x._year y._year){return true;}else if (x._year y._year){if (x._month y._month){return true;}else if (x._month y._month){return x._day y._day;}}//写完true,则其余情况falsereturn false;
}int main()
{Date d1(2024, 1, 28);Date d2(2024, 2, 26);//对象不能直接比较不能strcmp//errord1 d2//error:strcmp(d1,d2)//cout DateEqual(d1, d2) endl;//cout DateLess(d1, d2) endl;//为了可读性和通识性引入关键词operator//对运算符的需要重新控制//operator运算符 作函数名cout operator(d1, d2) endl;cout operator(d1, d2) endl;//等价写法但是注意传参参数的和函数的参数顺序绑定的不可任意交换参数顺序cout (d1 d2) endl;//cout operator(d1, d2) endl;cout (d1 d2) endl;//cout operator(d1, d2) endl;return 0;
}重载的运算符通常是具备一定意义的运算符。 注意以上的访问操作是基于类的成员变量处于pubilc状态的。 那么如何解决私有状态的正确访问呢
5.2、私有限定符情况 1.写“回调函数” Getyear()/ Getmonth()/ Getday() 2.直接在类里写其相关函数即可 私有限定符情况解决方法1
#include iostream
using namespace std;class Date
{
public:Date(int year 1900, int month 1, int day 1){_year year;_month month;_day day;}//解决方法1int Getyear(){return _year;}int Getmonth(){return _month;}int Getday(){return _day;}
private:int _year;int _month;int _day;
};bool operator(Date x, Date y)
{return x.Getyear() y.Getyear() x.Getmonth() y.Getmonth() x.Getday() y.Getday();
}bool operator(Date x, Date y)
{if (x.Getyear() y.Getyear()){return true;}else if (x.Getyear() y.Getyear()){if (x.Getmonth() y.Getmonth()){return true;}else if (x.Getmonth() y.Getmonth()){return x.Getday() y.Getday();}}return false;
}int main()
{Date d1(2024, 1, 28);Date d2(2024, 2, 26);cout operator(d1, d2) endl;cout operator(d1, d2) endl;//等价写法但是注意传参参数的和函数的参数顺序绑定的不可任意交换参数顺序cout (d1 d2) endl;//cout operator(d1, d2) endl;cout (d1 d2) endl;//cout operator(d1, d2) endl;return 0;
}私有限定符情况解决方法2
#include iostream
using namespace std;class Date
{
public:Date(int year 1900, int month 1, int day 1){_year year;_month month;_day day;}//解决方法2直接放进类中会报错运算符函数的参数太多。//因为包括了隐含的成员函数this指针。//所以去掉多于参数并且放进类之后本身也就只需要被比较的参数了//bool operator(const Date x, const Date y)bool operator(const Date y){return _year y._year _month y._month _day y._day;}//bool operator(const Date x, const Date y)bool operator(const Date y){if (_year y._year){return true;}else if (_year y._year){if (_month y._month){return true;}else if (_month y._month){return _day y._day;}}//写完true,则其余情况falsereturn false;}
private:int _year;int _month;int _day;
};int main()
{Date d1(2024, 1, 28);Date d2(2024, 2, 26);//cout operator(d1, d2) endl;//cout operator(d1, d2) endl;cout d1.operator(d2) endl;cout d1.operator(d2) endl;cout d1.operator(d1) endl;cout d1.operator(d1) endl;cout d2.operator(d2) endl;cout d2.operator(d2) endl;cout d2.operator(d1) endl;cout d2.operator(d1) endl;//等价写法但是注意传参参数的和函数的参数顺序绑定的不可任意交换参数顺序cout (d1 d2) endl;//cout operator(d1, d2) endl;cout (d1 d2) endl;//cout operator(d1, d2) endl;return 0;
}5.3、了解‘.*’操作符
.’ 等价于 -属于成员指针运算符不支持重载
#include iostream
using namespace std;class ob
{
public:void func(){cout void func() endl;}
};typedef void(ob::* pobfunc)();int main()
{pobfunc p ob::func;ob temp;//(*p)();//this(temp.*p)();return 0;
}6、赋值运算符重载
6.1、 赋值运算符重载
1.参数类型const T 传递引用可以提高传参效率 2.返回值类型T 返回引用可以提高返回的效率有返回值目的是为了支持连续赋值 3.检测是否自己给自己赋值 4.返回 * this 要复合连续赋值的含义
6.2、 拷贝构造函数与赋值运算符重载的区别 1.赋值运算符只能重载成类的成员函数不能重载成全局函数 原因赋值运算符如果不显式实现编译器会生成一个默认的。 此时用户再在类外自己实现一个全局的赋值运算符重载就和编译器在类中生成的默认赋值运算符重载冲突了故赋值运算符重载只能是类的成员函数。 2.用户没有显式实现时编译器会生成一个默认赋值运算符重载以值的方式逐字节拷贝。 注意内置类型成员变量是直接赋值的而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。 既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了还需要自己实现吗 答当然像日期类这样的类是没必要的。那么下面的类呢验证一下试试 注意如果类中未涉及到资源管理赋值运算符是否实现都可以一旦涉及到资源管理则必须要实现。 即与拷贝构造函数类似涉及malloc动态开辟的空间操作就是自己写编译器会把数组地址无脑拷贝
#include iostream
using namespace std;class Date
{
public:Date(int year 1900, int month 1, int day 1){_year year;_month month;_day day;}bool operator(const Date y){return _year y._year _month y._month _day y._day;}bool operator(const Date y){if (_year y._year){return true;}else if (_year y._year){if (_month y._month){return true;}else if (_month y._month){return _day y._day;}}return false;}//不写赋值重载编译器会自动生成但是只能是类的成员函数//因为当用户在类外自己实现一个全局的赋值运算符重载时就和编译器在类中生成的默认赋值运算符重载冲突了。//d1 d2//void operator(const Date d)//满足赋值运算符的连续赋值添加Date返回值类型。//传值和传引用返回又有一定的区别,传值只是拷贝传引用才能改变变量Date operator(const Date d){//添加if判断使其不会浪费空间资源去执行赋值操作。if (this ! d){_year d._year;_month d._month;_day d._day;return *this;}}void Print(){cout _year - _month - _day endl;}
private:int _year;int _month;int _day;
};int main()
{Date d1(2024, 1, 28);Date d2(2024, 2, 26);//拷贝构造Date d3(d1);//拷贝构造同类型中一个已存在对象进行初始化要创建的对象//d1 d2;//已经存在的对象一个拷贝赋值给另一个存在对象d1 d2;d1.Print();d2.Print();//连续赋值int i, j, k;i j k 10;//优先级cout ((i j) 10) endl;cout (i j 10) endl;//那么赋值重载的运算符能实现连续赋值操作吗//当然能解决没有找到void类型的右操作数的运算符。//修改返回值为类类型并加引用。//不写赋值重载编译器会自动生成d1 d2 d3;//偶尔会测试/失误的自己会给自己赋值//d1 d1;//添加if判断使其不会浪费空间资源去执行赋值操作。return 0;
}小结 1.用户没有显示实现时编译器会生成一个默认赋值运算符重载以值的方式逐字节拷贝 赋值重载与拷贝构造函数类似的赋值重载内置类型可由编译器自动赋值自定义类型调用它的赋值重载赋值。 2.不写赋值重载编译器会自动生成但是只能是类的成员函数因为当用户在类外自己实现一个全局的赋值运算符重载时就和编译器在类中生成的默认赋值运算符重载冲突了。 7、类的6个默认成员函数总结 1.构造函数和析构函数可归为一组内置类型不做处理自定义类型调用对应的构造函数和析构函数。 2.拷贝构造函数和赋值重载可归为一组内置类型拷贝或赋值(编译器无法干一些复杂的逻辑操作比如malloc开辟的空间处理等)自定义类型调用对应的拷贝构造函数和赋值重载
