类和对象(2)

编译器生成的默认析构函数价值

当一个类包含了其他类，比如leetcode里面的题目的时候，我们可以不写当前的类的默认构造，加入其他类，这样就能自然而然地初始化其他类和销毁其他类

class MyQueue{public:void Push(){}private:Stack s1,s2;
}

3.拷贝构造函数

3.1概念

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用（一般常用const修饰），在用已存在的类类型对象创建新对象时由编译器调用

3.2特征

• 拷贝构造函数是构造函数的一个重载形式
• 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用
• 默认生成的是浅拷贝
• 浅拷贝是存在问题的，对于像Stack这样的类，会导致同一块空间析构的时候释放两次。所以有些类是要手动实现深拷贝。
  • 假如不析构就会产生内存泄漏，因此一定要浅拷贝。

3.3拷贝构造的无穷递归

原因是这样的,如果没有&，当调用拷贝构造的时候，由之前的函数栈帧的学习中，对于拷贝构造函数的参数，将d1拷贝给参数发生的。而拷贝这个过程就是拷贝构造函数要进行的过程。因此发生了语义上的无穷递归。

class Date
{public:Date(int year=0,int month=1,int day=1){_year=year;_month=month;_day=day;}//Date d2(d1)Date(Date d)//error:存在递归拷贝{_year=d._year;_month=d._month;_day=d._day;}private:int _year=0;int _month=0;int _day=0;
};
int main()
{Date d1(2020,5,12);Date d2(2020,5,12);//如果上面发生更改，下面也要改。就很恶心//于是产生了拷贝构造Date d2(d1);<----->Date d2=d1;//***
}

下面说明的是，进行func的时候，需要将d1拷贝给参数d。

于是将d1拷贝给参数d的这个过程，需要调用拷贝构造函数。

于是可想而知，假如func函数是拷贝构造函数，就会存在自身无穷地调用自身。

而进行引用作为参数的时候，是不进行传值拷贝的

void func(Date d)
{}
void fund(Date& d)
{}
int main()
{Date d1(2020,5,12);func(d1);//这里调试可以发现跳到Date的拷贝构造函数fund(d1);//这里调用直接就进入fund了，因为是引用
}

递归的过程：

//Date d2(d1) //对象初始化的时候自动调用构造函数（此时为拷贝构造）
//调用之前先传参：Date d(d1)--->此时的传参又发生拷贝构造。如此就递归下去了   
Date(Date d)//error:存在递归拷贝{_year=d._year;_month=d._month;_day=d._day;}

由此说明传值的时候要用拷贝构造

因此解决方案是：传引用来处理。&d和&d1的地址同。

 Date(Date& d)//sol:引用解决{_year=d._year;_month=d._month;_day=d._day;}

3.4加上const的原因

同时忘了防止自己不小心赋值反了，把传引用的部分用const。导致拷贝错误还改变了自身的值。

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

3.5编译器默认生成的的拷贝构造——浅拷贝

因此对于malloc的类我们要手动实现进行深拷贝。

class Date
{public:Date(int year=0,int month=1,int day=1){_year=year;_month=month;_day=day;}private:int _year=0;int _month=0;int _day=0;
};
int main()
{Date d1(2020,5,12);Date d2(d1);
}

浅拷贝是传值拷贝，所以对于指针相关的就会导致将指针的值传过去。也就是指向了同一个地址。因此会导致同一块空间析构两次，abort操作系统发送信号终止进程。

class Stack
{public:Stack(int n=10){_a=(int*)malloc(sizeof(int)*n);cout<<"malloc:"<<_a<<endl;_size=0;_capacity=n;}~Stack(){if(_a){free(_a);cout<<"free:"<<_a<<endl;_a=nullptr;_size=_capacity=0;}}private:int *_a;int _size;int _capacity;
};
int main()
{     //浅拷贝问题Stack st1(10);Stack st2(st1);Stack st3(30);//st1=st3;(赋值operatro=)
}

3.6编译器默认生成的拷贝构造作用

默认生成的拷贝构造：

1. 对于内置类型成员，会完成按字节序的拷贝(浅拷贝)
2. 对于自定义类型成员，会调用该成员的类拷贝构造函数。（类似MyQueue中只包含两个Stack)

拷贝构造我们不写生成的默认拷贝构造函数，对于内置类型和自定义类型都会拷贝处理。但是处理细节是不一样的，这个和构造和析构是不一样的

#include
#include
using namespace std;class A{public:A(){}A(const A& a){cout<<"拷贝:A()"<<endl;}
};
class Data{public:Data(int year=1,int month=1,int day=1){_year=year;_month=month;_day=day;}~Data(){cout<<"~Data()"<<endl;}private:int _year;int _month;int _day;A _aa;
};
int main()
{     Data d1(2022,1,1);Data d2(d1);return 0;
}

4.运算符重载

4.1运算符重载

c++为了增强代码的可读性引入了运算符的重载，运算符重载是具有特殊名的函数。

4.1.1运算符重载的规则

双操作数的运算符重载的时候，规定第一个操作数是左操作数，第二个参数是右操作数。

• 函数名 operator操作符
• 运算符有几个操作数，operator重载的函数就有几个参数
• 不能通过连接其他符号来创建新的操作符
• 重载操作符必须有一个类类型或者枚举类型的操作数
• 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义
• 作为类成员的重载函数时，其形参看起来比操作数目少1成员函数的。操作符有一个默认的形参this，限定为第一个形参,第一个形参为发起对象
• .*、：：、sizeof、？：、. 不能重载。注意不是*，是.*

4.1.2运算符重载的实例

对于重载中需要成员变量访问，有四种方式。

1. 写成员变量的获取封装
2. 将成员变量改成公有
3. 友元函数(破坏了一些封装性)
4. 将运算符重载写到类里。**访问限定符只对类外面的才会受到限制，类内部的是不受限制的。**不过注意以成员函数的形式会有一个默认的this，因此参数要少一个。

• 将成员函数改成公有

class Date
{public:Date(int year=0,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;}int _year=0;int _month=0;int _day=0;
}
bool IsDateEqual(const Date& e1,const Date& e2)
{}///但是这么写麻烦，还要记函数。直接运算符重载就简洁明了
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(2020,5,12);Date d2(2020,5,12);//比如Date的对象想比较大小相等cout<<d1==d2<<endl;///编译器转化： ->operator==(d1,d2);这里就是一个函数调用cout<<operator==(d1,d2)<<endl;///实质内容，但是一般这么写可读性差    
}

• 将运算符写到类里

#include
using namespace std;class Data{
public:Data(int year=0,int month=0,int day=0){_year=year;_month=month;_day=day;}Data(const Data& d){_year=d._year;_month=d._month;_day=d._day;}///这里有隐藏的this指针的一个参数//bool operator>(const *this,d2);bool operator>(const Data& d2){if(_year > d2._year) return true;else if( _year == d2._year && _month > d2._month ) return true;else if( _year == d2. _year && _month == d2._month && _day > d2._day ) return true;else return false;}
private:int _year;int _month;int _day;
};
int main()
{Data d1(2021,1,20); Data d2(2021,1,16);cout<< ( d1 > d2 ) <<endl;cout<< (d1.operator>(d2) ) <<endl;//d1调用,使用operator>(&d1,d2);return 0;
}

4.1.3运算符重载的原理

VS下先去类里找有没有重载，没有再去看全局里有没有，再没有就报错。

linux下验证一下。

不过不重要。取决于编译器。

4.2赋值运算符重载

拷贝构造和赋值的区别。

拷贝构造：一个已经存在的对象拷贝初始化一个马上创建实例化的对象

赋值：两个已经存在的对象，之间进行赋值拷贝。

int main()
{Date d1(2020,4,11);d1.Print();Date d2(2020,4,15);d2.Print();d1=d2//两个对象都已经存在且初始好了，现在我想把d2赋值（拷贝）给d1  复制Date d3(d1);//d3 还不存在，构造d3时用d1去初始化Date d4 =d1 ;//特别注意：这里是拷贝构造，不是operator=，就是上文拷贝构造函数的等价。因为d4还不存在。
}

• 运算符重载是为了让自定义类型可以像内置类型一样去使用
• 自定义类型传参数和返回值时，在可以的情况下，尽量使用引用，减少拷贝
• 和默认的浅拷贝一样，也会产生问题同一块空间释放两次。和默认的拷贝构造一个道理.

4.2.1赋值运算符的返回值

//d3 = d1
//d3 = d3
//运算符重载是为了让自定义类型可以像内置类型一样去使用
void operator=(const Date &d)
{if(this!=&d)//针对自己给自己赋值,防止浪费{this->_year=d._year;this->_month=d._month;this->_day=d._day;}
}

出错的场景:

int i=0,j=1,k=2;
i=j=k;///连续赋值

因此考虑到连续赋值的情况，因此返回值要传对象。

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

并且考虑到对象生命周期，为了效率可以传对象的引用。

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

4.2.2赋值运算符的实例

Tips：如果是自己给自己赋值，加一个this != & d以地址的比较提高效率。

#include
using namespace std;class Data{
public:Data(int year=0,int month=0,int day=0){_year=year;_month=month;_day=day;}Data(const Data& d){_year=d._year;_month=d._month;_day=d._day;cout<<"Data(const Data&d)"<<endl;}bool operator>(const Data& d2){if(_year > d2._year) return true;else if( _year == d2._year && _month > d2._month ) return true;else if( _year == d2. _year && _month == d2._month && _day > d2._day ) return true;else return false;}Data& operator=(const Data& d2){if( this != &d2 )//针对自己给自己赋值,防止浪费{_year=d2._year;_month=d2._month;_day=d2._day;}return *this; //出了作用域还存在，可以引用返回，减少一层拷贝构造}void Print() const {cout<<_year<<" "<<_month<<" "<<_day<<endl;}
private:int _year;int _month;int _day;
};
int main()
{Data d1(2021,1,20); Data d2(20l21,1,16);Data d3(d2);d3 = d2 = d1;;///当想重新赋值的时候，这里是重载赋值运算符的意义d2.Print();d3.Print();return 0;
}

4.2.3赋值运算符的主要五个特性及编译器生成的默认赋值运算重载

1. 参数类型
2. 返回值
3. 检测是否自己给自己赋值
4. 返回*this
5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个。

编译器默认生成赋值重载，跟拷贝构造做的事情类似。

对于内置类型成员，按照字节序进行浅拷贝。

对于自定义类型成员，调用它的operator=。

因此如果当前类有动态开辟的内存，同样需要手动写赋值运算符重载进行深拷贝。

5.实现一个完善的日期类

5.1前置++和后置++(占位参数)

前置++和后置++的区别：

++d1—>d1.operator++(&d1);

d1+±–>d1.operator++(&d1,0(int));这个int是编译器自己传的。

由此可以看出，如果是自定义类型的++，前置++的拷贝次数更少，效率更高。

	//++d1Date& operator++(){*this += 1;return *this;}//d1++;Date operator++(int)//为了构成函数重载{Date res = *this;*this += 1;return res;}

5.2实例

5.2.1复用运算符重载

实现了>就可以利用>来实现>=和<。

实现了=就可以实现!=

bool operatpr>(const Data& d);
bool operatpr<(const Data& d);
bool operatpr>=(const Data& d);
bool operatpr<=(const Data& d);
bool operatpr==(const Data& d);
bool operatpr!=(const Data& d);

不仅Data类可以实现成这样子，其他类也可以复用。

5.2.2日期加减

注意日期在减一个负数的时候，判断一下，然后这部分要复用一下日期加的。

所以有日期和数字的加减。还有两个日期之间的减法获得多少天。

这里虽然可以更暴力的从小到大跑天数减，但是我们可以复用刚才的运算符重载达到更加简洁的效果。

int Date::operator-(const Data& d)
{Data max=*this;Data min=d;int flag=1;if(* this < d){max = d;min = *this;flag = -1;}int count=0;while(min != max ){++min;++count;}return count* flag;
}

5.2.3判断星期

以1900年1月1日的星期一为标准。

5.2.4实现

#include
#include
using namespace std;class Date
{
public://四年一润百年不润，四百年一润bool isYear(int year){if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) return true;return false;}int getMaxDays(int year, int month)//检查对应年的对应月的最大天数{int days = 0;static int months[] = { 31,28,31,30,31,30,31,31,30,31,30,31 };days = months[month - 1];if (month == 2 && isYear(year) ){days=29;}return days;}Date(int year = 0, int month = 1, int day = 1)//构造函数{if (year >= 0 && month > 0 && month < 13 && day>0 && day <= getMaxDays(year, month)){_year = year;_month = month;_day = day;}else{throw "输入非法";}}Date(const Date& d) //拷贝构造函数{_year = d._year;_month = d._month;_day = d._day;}bool operator==(const Date& d)//判断日期相等{return this->_year == d._year && this->_month == d._month && this->_day == d._day;}bool operator<(const Date& d) //判断日期小于{if (this->_year != d._year) return this->_year < d._year;if (this->_month != d._month) return this->_month < d._month;return this->_day < d._day;}bool operator<=(const Date& d) //判断日期小于等于{return *this < d || *this == d;}bool operator>(const Date& d)//判断日期大于{return !( *this <= d );}bool operator>=(const Date& d)//判断日期大于等于{return ! ( *this < d);}bool operator!=(const Date& d)///日期不等于{return !( *this == d );}Date operator+(int days)//日期的加天数{if (days < 0){return *this - (-days);}Date res(*this);res._day += days;while (res._day >= getMaxDays(res._year, res._month)){res._day -= getMaxDays(res._year, res._month);res._month++;if (res._month == 13){res._month = 1;res._year++;}}return res;}//++d1Date& operator++(){*this += 1;return *this;}//d1++;Date operator++(int)//为了构成函数重载{Date res = *this;*this += 1;return res;}Date operator-(int days)//日期减后是多少天{Date res = *this;if (days < 0){return res + (-days);}while (days){int cnt = min(days, res._day);res._day -= cnt;days -= cnt;if (res._day == 0){res._month--;if (res._month == 0) --res._year, res._month = 12;if (res._year < 0){throw "年份为负数";}res._day = getMaxDays(res._year, res._month);}}return res;}Date& operator-=(int days)//日期-={*this = (*this - days); //调用重载的=return *this;}long long operator-(const Date& d)//两个日期中间差多少天{Date d1 = *this; Date d2(d); //均为拷贝构造//交换大小if (d1 < d2){swap(d1._year, d2._year); swap(d1._month, d2._month); swap(d1._day, d2._day);}//方便点的做法是全部转化成天数后再加减long long cnt = 0;for (int i = 0; i < d1._year; i++){if (isYear(i)) cnt += 366;else cnt += 365;}for (int i = 1; i < d1._month; i++){cnt += getMaxDays(d1._year, i);}for (int i = 1; i <= d1._day; i++){cnt++;}for (int i = 0; i < d2._year; i++){if (isYear(i)) cnt -= 366;else cnt -= 365;}for (int i = 1; i < d2._month; i++){cnt -= getMaxDays(d2._year, i);}for (int i = 1; i <= d2._day; i++){cnt--;}return cnt;}//--d;Date& operator--(){*this -= 1;return *this;}Date operator--(int){Date tmp(*this);*this -= 1;return tmp;}Date& operator+=(int days) //将日期变成+后的天数{if (days < 0){return *this -= -days;}(*this)._day += days;while ( (*this)._day >= getMaxDays( (*this)._year, (*this)._month)){(*this)._day -= getMaxDays((*this)._year, (*this)._month);(*this)._month++;if ((*this)._month == 13){(*this)._month = 1;(*this)._year++;}}return *this;}Date& operator=(const Date& d){if (this != &d){this->_year = d._year;this->_month = d._month;this->_day = d._day;}return *this;}friend ostream& operator <<(ostream& os,const Date& d) //重载输出{return os << d._year << "-" << d._month << "-" << d._day;}~Date(){}private:int _year;int _month;int _day;
};
int main(void)
{Date d(2021,9,6);cout << d << endl;cout << (d + 100) << endl;cout << (d == (d + 1) )<< endl;cout << (d < d + 1) << endl;d += 10;cout << d << endl;Date d2 = d;//拷贝构造cout << d2 << endl;Date d3(2021, 9, 8);cout << d3 << endl;d2 = d3;///重载赋值运算符cout << d2 << endl;//测试日期相减cout << d3 << endl;cout << d << endl;cout << d3 - d << endl;Date dq(2020, 2, 5); Date dqq(2021, 9, 8);cout << dq - dqq << endl;//测试日期减后是什么时候cout << d3 - 20 << endl;d3 -= 20;cout << d3 << endl;d3 += 20;cout << d3 << endl;//测试++++d3;cout << d3 << endl;cout << d3++ << endl;return 0;
}

5.3声明和定义分离后的一些issue

然后就发现调用的部分没有后置const，连锁反应报错

//d1-d2
int operator-(const Date& d) const
{}
void Fun(const Date& d3,const Date& d4)
{cout<< d3 - d4 <

class Date
{public:Date(int year=0,int month=1,int day=1){_year=year;_month=month;_day=day;}void Print()/* Date* const this，const保护this指针不能变*/{}private:int _year;int _month;int _day;
};
int main()
{Date d1(2021,9,8);d1.Print();//&d-Date* ,传过去只读，权限可以缩小，所以可以调用
}

class Date
{public:Date(int year=0,int month=1,int day=1){_year=year;_month=month;_day=day;}void Print()/* Date* const this*/{}///void Print(Date* const this) 权限放大了。需要加const变成 const Date* const this。但是恶心的地方在于this是隐含的。所以把const放在成员函数后面。void Print() const{}/*---->编译器处理： void Print(const Date* this){//注意我们的const修饰的是*this，不是this}*/private:int _year;int _month;int _day;
};
int main()
{const Data d2;d2.Print();//&d2 - const Data*//这里的&d 是 const Date* d; 表示*d 不能变
}

class Date
{public:void f1() //void f1(Date* this){f2();//this->f2(this);}void f2() const; //void f2(const Date* this)-->缩小{}void f3()//void f3(Date* this) --->放大了{}void f4() const//void f4(const Date* this){f3();//this ->f3(this);}
};

class AA()
{
public:AA(){}
};
int main()
{AA aa1;cout<<&aa1<<endl;const AA aa2;cout<<&aa2<<endl;
}

class Date
{public:Date(int year=0,int month=1,int day=1){_year=year;_month=month;_day=day;}Date* operator&()///10 // Date*{cout<<"operator&()"<

C c;
int main()
{A a;B b;static D d;return 0;
}

class Widget{public:Widget(){}Widget& Widget(const Widget& widget){cout<<"Widget(const Widget& )"<<endl;}
}
Widget f(Widget u)
{return u;
}
int main()
{Widget y = f(x);
}

class Widget{public:Widget(){}Widget& Widget(const Widget& widget){cout<<"Widget(const Widget& )"<<endl;}Widget& operator=(const Wideget& widget){cout<<"operator="<<endl;	}
}
Widget f(Widget u)
{return u;
}
int main()
{Widget x;Widget y;y = f(x);//此时是赋值,不能优化
}

class Widget{public:Widget(){}Widget& Widget(const Widget& widget){cout<<"Widget(const Widget& )"<<endl;}Widget& operator=(const Wideget& widget){cout<<"operator="<<endl;	}
}
Widget f(Widget u)
{return u;
}
int main()
{f(Widget());
}

Widget f(Widget u)
{Widget v(u);Widget w=v;return w;
}
int main()
{Widget x;Widget y= f(f(x));
}

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！