目录
注意：一般运算符重载都定义在类里面，如果定义全局的话，就会要把成员变量改为公有的，一般这样不好，或者用友元函数的方法，但是最常用的就是定义在类里面。方便一些。
绪论：
我们给出一个空类真的里面什么都没有吗？并不是，任何类在什么都不写的情况下，编译器会默认生成六个默认成员函数（用户没有实现，编译器会自动生成的成员函数称为默认成员函数）。假如我们自己实现了编译器就不会生成了，有些类需要我们自己写，而有些类不需要我们自己写。
<一>构造函数
1.概念
对于date类：
#include<iostream>
using namespace std;
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void print()
{
cout << _year << '/' << _month << '/' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};一个日期类我们可以通过加入一个成员函数（Init）来实现给对象初始化，但是这这回有有一个问题，有时候会忘记调用这个成员函数就会造成很不好的后果，有点太麻烦了。这就需要我们用到构造函数了。
构造函数：是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证 每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。
2,特征
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任 务并不是开空间创建对象，而是初始化对象。
特征
1，函数名于类名相同。
2，无返回值。
3，对象实例化的同时，编译器自动调用对应的构造函数。
4，构造函数的也可以重载，可以写多个构造函数，这样就会有多种初始化方式。一般会将无参和半缺省合并直接用全缺省来表示。
class Date
{
public:
Date()//可以无参构造。/调用/Date a;
{
_year = 0;
_month = 0;
_day = 0;
}
Date(int year, int month,int day)//可以带参构造。 /调用/ Date a(2022,10,20);
{
_year = year;
_month = month;
_day = day;
}
Date(int year, int month =10, int day = 20)//可以半缺省。/调用/ Date a(2022) 或者 Date a(2022,10); 或者 Date a(2022,10,20);
{
_year = year;
_month = month;
_day = day;
}
Date(int year = 2022, int month =10 , int day = 20)//可以全缺省。 /调用/Date a; 或者 Date a(2022); 或者 Date a(2022,10); 或者 Date a(2022,10,20);
{
_year = year;
_month = month;
_day = day;
}
//一般直接如果自己写构造函数的话，就会使用全缺省的构造函数，可以涵盖所有的对象定义方式。
void print()
{
cout << _year << '/' << _month << '/' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date a();//注意不能这样写。这是函数的声明，不是类对象的定义。
//注意这里的通过无参构造函数在创建对象的时候，对象后面不用加（），否则就成了函数的声明。
return 0;
}5，如果类中没有显示定义的构造函数，则c++编译器会自动生成一个无参的默认成员函数，一旦用户显示定义编译器将不再生成。
class Date
{
public:
Date(int year, int month=10, int day=20) //半缺省 / 调用 / Date a(2022) 或者 Date a(2022, 10); 或者 Date a(2022, 10, 20);
{
_year = year;
_month = month;
_day = day;
}
void print()
{
cout << _year << '/' << _month << '/' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date a;
//将Date屏蔽后可以编译通过，编译器生成了一个无参的默认构造函数。
//将Date放开后，编译器就不再生成，就会出现问题，没有合适的默认构造函数可用。
/// 应该调用 / Date a(2022) 或者 Date a(2022, 10); 或者 Date a(2022, 10, 20);
return 0;
}6，编译会自动生成默认构造函数，为什么还需要我们自己定义一个构造函数呢。答案就是编译器自动生成的构造函数，对内置类型不处理，而对自定义类型又会调用该自定义类型的默认构造函数。有时候不能满足我们的需求。就需要我们自己写默认构造函数。
#include<iostream>
using namespace std;
class Time
{
public:
Time(int hour = 0, int minute = 0, int second = 0)//默认构造函数
{
cout << "time(int ,int ,int)" << endl;
_hour = hour;
_minute = minute;
_second = second;
}
//这个也是默认构造函数 但是一般用上面的定义方式。
//Time()//默认构造函数
//{
// cout << "time()" << endl;
// _hour = 0;
// _minute = 0;
// _second = 0;
//}
void print()
{
cout << _hour<<'/' << _minute<<'/' << _second << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
void print()
{
cout << _year<<'/' << _month<<'/' << _day << '/' << endl;
_a.print();
}
private:
//内置类型
int _year;
int _month;
int _day;
//自定义类型
Time _a;
};
int main()
{
Date a;
a.print();
return 0;
}运行结果：
我们可以看到 对于内置类型并没有初始化，而是随机数。对于自定义类型则调用了他的默认构造函数。
注意：c++11中针对内置类型成员不初始化的缺陷，又打了补丁：内置类型的成员变量在类中声明的时候可以给默认参数。
class Date
{
public:
void print()
{
cout << _year<<'/' << _month<<'/' << _day << '/' << endl;
_a.print();
}
private:
//内置类型
int _year = 2022;
int _month = 10;///c++11的补丁 内置类型声明的时候可以给默认值
int _day = 20;//就是一种缺省值
//自定义类型
Time _a;
};
int main()
{
Date a;
a.print();
return 0;
}运行结果为：
这样也能兼顾内置；类型的问题了。
7.无参的构造函数和全缺省的构造函数都称为默认构造函数。并且默认构造函数只能有一个。也就是无参的全缺省的构造函数只能有一个存在。俩都存在就会造成歧义。
注意：无参的构造函数，全缺省的构造函数 ，以及我们没写编译器自动生成的构造函数都是默认构造函数。如果我们写的是半缺省的构造函数，就必须要传参了。如果我们写了，但是不是默认构造函数，普通的构造函数就有不传参定义就会有问题。
class Time
{
public:
Time(int hour = 0, int minute = 0, int second = 0)//默认构造函数
{
cout << "time(int ,int ,int)" << endl;
_hour = hour;
_minute = minute;
_second = second;
}
//这个也是默认构造函数 但是一般用上面的定义方式。//但是两个不能同时存在。会出现调用歧义的问题。
Time()//默认构造函数
{
cout << "time()" << endl;
_hour = 0;
_minute = 0;
_second = 0;
}
void print()
{
cout << _hour << '/' << _minute << '/' << _second << endl;
}
private:
int _hour;
int _minute;
int _second;
};<二>析构函数
析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。资源包括动态开辟的空间，文件的关闭等。相当于C语言阶段写的destroy函数。
特性
1 析构函数名是在类名前加上字符 ~。
2 无参数无返回值类型。
3 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构 函数不能重载。
4 对象生命周期结束时，C++编译系统系统自动调用析构函数。避免自己遗忘的问题。
5 一般有资源需要释放一般使用过：malloc fopen的类都需要自己写默认析构函数。如果编译器自动生成的够用就不需要自己写。
class stack
{
public:
stack(int capacity = 10)//这是默认构造函数
{
cout << "stack()" << endl;
_capacity = capacity;
_array = (int*)malloc(sizeof(int) * capacity);
_size = 0;
}
~stack()//这就是一个标准的默认析构函数。//需要我们手动释放空间，或者关闭文件。
{
cout << "~stack()" << endl;
if (_array)
{
free(_array);
_array = nullptr;
_size = 0;
_capacity = 0;
}
}
private:
int* _array;
int _size;
int _capacity;
};
int main()
{
stack a;
return 0;
}6 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定义类型会调用他的默认析构函数。对于内置类型不处理，内置类型也不需要处理。因为没有额外的空间。
class stack
{
public:
stack(int capacity = 10)
{
cout << "stack()" << endl;
_capacity = capacity;
_array = (int*)malloc(sizeof(int) * capacity);
_size = 0;
}
~stack()
{
cout << "~stack()" << endl;
if (_array)
{
free(_array);
_array = nullptr;
_size = 0;
_capacity = 0;
}
}
private:
int* _array;
int _size;
int _capacity;
};
class My_Queue
{
public:
//
private:
//内置类型
int size;
//自定义类型 ，会调用他的析构函数。和构造函数相同。
stack push;
stack pop;
};
int main()
{
My_Queue a;
//和构造函数相同，在a定义的时候会生成自己的默认构造函数，函数内部对内置类型不处理，对自定义类型会调用他的默认构造函数
//在a的生命周期结束的时候，a类也会自动生成一个默认析构函数，对自定义类型会调用他自己的默认析构函数。
//内置类型不需要资源清理，最后直接由造作系统将其内存回收即可。
return 0;
}注意：那个类对象的声明周期结束，调用那个类的默认析构函数，该默认析构函数内部，对内置类型不处理，对自定义类型会调用他的默认析构函数。
7对于有资源申请时候一定要写析构函数，否则就会造成内存泄漏的问题。
<三>拷贝构造
在创建对象的时候，我们可否创建一个与已存在对象一模一样的新对象。这个时候就需要用到拷贝构造函数了。拷贝构造也是一种构造函数，是构造函数的一种重载。只是参数不一样。
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
特性
1，拷贝构造函数是构造函数的一个重载形式。
2，拷贝构造函数的参数只有一个且必须是对应的对象类 类型的引用，使用传值方式编译器会直接报错，因为会引发无穷递归调用。
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year =2022, int month=10, int day=20)
{
_year = year;
_month = month;
_day = day;
}
Date(const Date& d)//这就是一个标准的拷贝构造函数，参数是对应类型的const引用
{
_year = d._year;
_month = d._month;
_day = d._day;
}//虽然用指针也能实现对应的功能但是，那样只是一个普通的构造函数，不是拷贝构造。
Date(const Date d)//这里是错误的会引发无穷递归。
{
_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;
Date d2(d1);
d1.print();
d2.print();
return 0;
}想要了解为什么这里会引发无穷递归？我们需要先知道，什么情况下会调用拷贝构造这个函数。
void fun(Date d)
{
;
}
int main()
{
Date d1;//这里调用默认构造函数
//对象定义的时候会调用拷贝构造函数
Date d2(d1);
//传值传参的时候也会调用拷贝构造
fun(d1);
//做返回值的时候也会调用拷贝构造。
return 0;
}回到我们刚刚的问题为什么拷贝构造传值的时候会引发无穷递归呢？用d1给d2传值传参的时候，会调用拷贝构造函数，又会去传参，就这样一直调用下去无穷递归。
3，如果未显示定义，编译器会生成默认的拷贝构造函数，默认的拷贝构造函数。默认的拷贝构造函数按照内存存储的字节序完成拷贝，这种叫做浅拷贝，或者值拷贝。有些时候浅拷贝是我们需要的，有些时候并不是我们需要的值，例如一个stack类型的类，里面会malloc内存空间地址。如果我们只是简单的值拷贝的话 就会出现一个问题。两个对象同时指向同一块内存空间地址。这样是错误的。是不需要深拷贝就可以的，比如日期类
class Time
{
public:
Time(int hour = 0, int minute = 0, int second = 0)//默认构造函数
{
_hour = hour;
_minute = minute;
_second = second;
}
void print()
{
cout << _hour<<'/' << _minute<<'/' << _second << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
void print()
{
cout << _year<<'/' << _month<<'/' << _day << '/' << endl;
_a.print();//注意在这里我们无法直接访问到Time _a 私有的成员变量。
}
private:
//内置类型
int _year = 2022;//偷懒给了默认值
int _month = 10;
int _day = 20;
//自定义类型
Time _a;
};
int main()
{
Date a;
Date b(a);
b.print();
return 0;
}stack就需要深拷贝
class stack
{
public:
stack(int capacity = 10)//默认构造函数
{
_arr = (int*)malloc(sizeof(int) * capacity);
_size = 0;
_capacity = capacity;
}
~stack()
{
if (_arr)
{
free(_arr);
_arr = nullptr;
_capacity = 0;
_size = 0;
}
}
void push(int x)
{
_arr[_size] = x;
_size++;
}
stack(stack& a)
{
//这里只是演示就不扩容了
_arr = (int*)malloc(sizeof(int) * a._capacity);
_capacity = a._capacity;
_size = a._size;
memmove(_arr, a._arr, sizeof(int) * _capacity);//注意这里不能丢掉
}
private:
int* _arr;
int _size;
int _capacity;
};
int main()
{
stack a;
a.push(1);
a.push(2);
a.push(3);
a.push(4);
stack b(a);
//大家可以通过监视窗口去看看 b和a的地址肯定是不同的。
return 0;
}4， 一般需要写析构函数的类，都需要写拷贝构造函数。其实深拷贝就是在拷贝的开辟的资源。如果一个类没有涉及到资源申请时，拷贝构造函数是否写都可以，但是一旦涉及到资源申请，就必须写拷贝构造。否则就是浅拷贝。
5，有时候我们写的类，不写拷贝构造就会出现错误，而有些就刚刚好是我们需要的。这个要视情况而定。（上面的例子就会报错，同一块空间被free两次这是错误的）。
6，什么时候会用调用拷贝构造呢？1使用已存在的对象创建新对象，2函数传值传参，3函数返回值类型为类类型的对象。（可以用引用解决一些问题）
class Date
{
public:
Date(int year =2022, int month=10, int day=20)
{
_year = year;
_month = month;
_day = day;
}
Date(const Date& d)//这就是一个标准的拷贝构造函数，参数是对应类型的const引用
{
cout << "Date(Date & d)" << endl;
_year = d._year+100;
_month = d._month+100;
_day = d._day+100;
}
void print()
{
cout << _year << '/' << _month << '/' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
Date d1; //这里调用默认构造函数
void fun1(Date d)
{
;
}
Date fun2()
{
return d1;
}
int main()
{
//对象定义的时候会调用拷贝构造函数
Date d2(d1);
//传值传参的时候也会调用拷贝构造
fun1(d1);
//做返回值的时候也会调用拷贝构造。
fun2();
return 0;
}结果为：
<四>赋值运算符重载
1，运算符重载（都是针对自定义类型的，和内置类型没关系）
c++为了增强代码的可读性，引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有返回值类型，函数名字以及参数列表。其返回值类型于参数列表与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符号。
函数原型为：返回值类型 operator运算符（参数列表）
注意：
- 不能通过连接其他符号来创建新的操作符：比如operator@
- 重载操作符必须有一个类类型的参数
- 用于内置类型的运算符，其含义不能修改，例如内置类型的 + 不能该变他的含义。
- 作为类成员函数重载时，其形参看起来比操作数数目少一个，因为成员函数的第一个参数为隐藏的this指针。
- （.* :: sizeof ? : . ）注意以上5个运算符不能重载。这个经常在笔试选择题中出 现。
class Date
{
public:
Date(int year = 2022, int month = 10, int day = 21)
{
_year = year;
_month = month;
_day = day;
}
void print();
bool operator==(const Date& d2);
bool operator>(const Date& d2)
{
if (_year > d2._year)
{
return true;
}
else if (_year < d2._year)
{
return false;
}
else
{
if (_month > d2._month)
{
return true;
}
else if (_month < d2._month)
{
return false;
}
else
{
if (_day > d2._day)
{
return true;
}
else if (_day < d2._day)
{
return false;
}
else
{
return false;
}
}
}
}
bool operator>=(Date& d2)
{
//return *this > d2 || *this == d2;
return this->operator>(d2) || this->operator==(d2);
}
int GetMonthDay(int year, int month)//获取对应年对应月的天数。
{
//可以把他改为静态的，不用每次调用就创建。
static int arr[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
{
return 29;
}
else
{
return arr[month];
}
}
Date& operator+=(int day)
{
_day += day;
while (_day > GetMonthDay(_year, _month))
{
int ret= GetMonthDay(_year, _month);
_day -= ret;
_month++;
if (_month == 13)
{
_year++;
_month = 1;
}
}
return *this;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2;
cout<<(d1==d2)<<endl;//隐式调用
cout<<d1.perator==(d2)<<endl;//显示调用
//两种调用都是相同的意思，但是一般用隐式调用。可读性更高。
return 0；
}注意：一般运算符重载都定义在类里面，如果定义全局的话，就会要把成员变量改为公有的，一般这样不好，或者用友元函数的方法，但是最常用的就是定义在类里面。方便一些。
2，赋值运算符重载
1. 赋值运算符重载格式
- 参数类型：const T&，传递引用可以提高传参效率。
- 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值。
- 检测是否自己给自己赋值。
- 返回*this ：要复合连续赋值的含义。
class Date
{
public:
Date(int year = 2022, int month = 10, int day = 21)
{
_year = year;
_month = month;
_day = day;
}
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
//赋值重载
Date& operator=(const Date& d)
{
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(2001, 9, 9);
Date d2;
d2.print();
d2 = d1;
d2.print();
return 0;
}
- 赋值运算符只能重载成类的成员函数不能重载成全局函数
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void print()
{
cout << _year << '/' << _month << '/' << _day << endl;
}
//公有的
int _year;
int _month;
int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
if (&left != &right)
{
left._year = right._year;
left._month = right._month;
left._day = right._day;
}
return left;
}
int main()
{
Date d1(2001, 9, 9);
Date d2;
d2.print();
d2 = d1;
d2.print();
return 0;//这里编译器会报错
}
原因：赋值运算符重载是一个默认成员函数，赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现 一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值 运算符重载只能是类的成员函数。
- 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注 意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符 重载完成赋值。
这里回到我们刚刚写的第一个例子Date类，如果我们没有给赋值重载，也是可以达到我们想要的意思的。和拷贝构造差不多。如果我没没实现编译会自动生成一个，这个赋值重载对于内置类型直接memmove，对于自定义类型直接调用他的赋值重载。
扫一扫
814
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
