类和对象（中）
目录
1.类的6个默认成员函数
2.构造函数
2.1 概念
2.2 特性
3.析构函数
3.1 概念
3.2 特性
4.拷贝构造函数
4.1 概念
4.2 特性
5.赋值运算符重载
5.1 运算符重载 （重要）
5.2 赋值运算符重载
5.3 Date类的其他运算符重载
6.const成员函数
7.取地址及const取地址操作符重载
1.类的6个默认成员函数
如果一个类中什么成员都没有，简称为空类。空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。
2.构造函数
2.1 概念
对于以下Date类：
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;
};
int main()
{
Date d1;
d1.Init(2022, 7, 5);
d1.Print();
Date d2;
d2.Init(2022, 7, 6);
d2.Print();
return 0;
}对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，一方面是有点麻烦，另一方面还可能有所遗忘，那能否在对象创建时，就将信息设置进去呢？
构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。
2.2 特性
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
特性如下：
-
函数名与类名相同。
-
无返回值。
-
对象实例化时编译器自动调用对应的构造函数。
-
构造函数可以重载
class Date
{
public:
// 1.无参构造函数
Date()
{}
// 2.带参构造函数
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
void TestDate()
{
Date d1; // 调用无参构造函数
Date d2(2015, 1, 1); // 调用带参的构造函数
//Date d3();//错误
}注意：无参构造函数的调用不要加()，否则就成了函数声明。
构造函数是6大默认成员函数之一，我们不写时编译器自动生成 。
-
如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦户显式定义（任何一个）编译器将不再生成。
class Date
{
public:
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
return 0;
}上述代码我们不写构造函数仍然可以编译通过，因为编译器生成了一个无参的默认构造函数。
但我们一旦示定义一个有参的构造函数呢？
class Date
{
public:
// 如果用户显式定义了构造函数，编译器将不再生成
Date(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;
};
int main()
{
Date d1;
return 0;
}代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成默认的无参构造，Date没有合适的默认构造函数可用。
但是我们发现：d对象经过编译器生成的默认构造后，三个成员依然是随机值，没有初始化，这是编译器没有生成默认构造吗？主要因为：
-
编译器默认生成的构造函数，针对内置类型不做处理，针对自定义类型去调用自定义类型的默认构造。
-
内置类型：C/C++自带的类型，int......指针（任何类型的指针都是内置类型）
-
自定义类型：struct/class
所以不是没有生成构造函数，而是因为Date类的成员全是内置类型，生成的默认构造没有处理。
class Time
{
public:
Time()
{
cout << "Time()" << endl;
_hour = 0;
_minute = 0;
_second = 0;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year;
int _month;
int _day;
// 自定义类型
Time _t;//调用Time类的默认构造
};
int main()
{
Date d;
return 0;
}
如果自定义类型没有可用的默认构造，比如用户自己定义了一个有参的构造，此时编译报错。
class Time
{
public:
Time(int hour, int minute, int second)
{
cout << " Time(int hour, int minute, int second)" << endl;
_hour = hour;
_minute = minute;
_second = second;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year;
int _month;
int _day;
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}
内置类型和自定义类型 没有做到统一，可以认为是早期C++语法设计时的一个缺陷，针对这个缺陷，C++11打了补丁：内置类型的成员变量可以给一个默认值，默认构造时使用默认值初始化对象。
class Time
{
public:
Time()
{
cout << "Time()" << endl;
_hour = 0;
_minute = 0;
_second = 0;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型),可以给默认值
int _year = 1970;
int _month = 1;
int _day = 1;
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}
-
默认构造函数有哪些？（特点：不传参数就可以调用）
-
我们不写，编译器自动生成的默认构造函数。
-
我们显示定义的无参构造函数。
-
我们显示定义的全缺省构造函数。（有参构造和无参构造都能用，最常用）
class Date
{
public:
Date()
{
_year = 1900;
_month = 1;
_day = 1;
}
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
void Test()
{
Date d1;
}上述代码编译不通过，两个都是默认构造，调用时出现歧义。
-
总结：
-
一般的类都需要我们自己写默认构造函数，不让编译器自动生成；显示定义一个全缺省的默认构造，这样无参和有参都能使用。
-
特殊情况下也会使用编译器默认生成的，如：类中成员变量全是自定义类型（比如MyQueue类，里面全是Stack类）或者自定义类型较多（内置类型使用C++11的补丁）。
3.析构函数
3.1 概念
一个类的Destory函数类似Init函数，使用上有诸多不便，而且相比Init函数更容易忘记使用并且造成内存泄露，这是C语言的一个缺陷，针对这个缺陷C++设计了析构函数 。
析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
3.2 特性
-
析构函数名是在类名前加上字符 ~。
-
无参数无返回值类型。
-
一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。
-
对象生命周期结束时，C++编译系统系统自动调用析构函数。
析构函数剩余的其它特性和构造函数完全相同：
-
我们不写，编译器默认生成一个析构函数；默认生成的析构函数针对内置类型不做处理（内置类型本身也不需要清理，系统直接将其内存回收即可），针对自定义类型去调用自定义类型的析构函数。
class Time
{
public:
~Time()
{
cout << "~Time()" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year = 1970;
int _month = 1;
int _day = 1;
// 自定义类型
Time _t;
};
int main()
{
Date d;
return 0;
}
-
涉及资源申请的类（也就是从堆中malloc、relloc出一块空间）的析构函数，一定要用户自己显示写，否则造成内存泄漏。
涉及资源申请的类，必定会malloc/relloc出一块空间并交给一个指针（指针是内置类型）来维护这块空间，编译器默认生成的析构函数不处理内置类型，所申请的空间没有得到释放，造成内存泄漏。
typedef int STDateType;
class Stack
{
public:
//构造函数，显示写一个全缺省的
Stack(int capacity = 4)
{
_a = (STDateType*)malloc(capacity * sizeof(STDateType));
_top = 0;
_capacity = capacity;
}
//析构函数，一定要显示写，否则造成内存泄漏
~Stack()
{
free(_a);
_top = 0;
_capacity = 0;
}
private:
STDateType* _a;
int _top;
int _capacity;
};-
总结
-
需要写析构的：有涉及资源申请的内置类型（指针），如Stack类。
-
不需要写析构的，编译器默认生成的够用：
1.类中全是自定义类型，比如MyQueue类；
2.类中全是没有涉及资源申请的内置类型，比如Date类。
-
总结下来：没有涉及资源申请的指针需要手动释放，编译器默认生成的够用。
4.拷贝构造函数
4.1 概念
创建对象时，可以创建一个与已存在对象一某一样的新对象。
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
-
使用引用：相比传值，传引用效率更高（而且只能传引用，下面解释）。
-
使用const引用：
一方面可以防止误操作修改了参数的对象引用。
另一方面可以让const对象的引用 也传进来进行拷贝。
4.2 特性
-
拷贝构造函数是构造函数的一个重载形式。
-
拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错。 因为会引发无穷递归调用。
拷贝构造函数使用传值传参，形参是实参的一份拷贝，实参传给形参时也会进行拷贝构造，就会再次调用拷贝构造，这个拷贝构造传递参数时又会继续调用拷贝构造，无穷无尽，直至栈溢出。
传值传参和传值返回都会调用拷贝构造函数。
class Date
{
public:
Date(int year = 1900, 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;
}
/*
Date(const Date d)//错误写法
{
_year = d._year;
_month = d._month;
_day = d._day;
}
*/
private:
int _year;
int _month;
int _day;
};
拷贝构造函数剩余的其它特性和构造函数相同：
-
我们不写，编译器默认生成一个拷贝构造函数；默认生成的拷贝构造函数针对内置类型是按照字节方式直接拷贝的，针对自定义类型去调用自定义类型的拷贝构造函数。
默认的拷贝构造函数，对象会根据内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。（这里也是兼容了C结构体的拷贝）
class Time
{
public:
Time()
{
_hour = 1;
_minute = 1;
_second = 1;
}
Time(const Time& t)
{
_hour = t._hour;
_minute = t._minute;
_second = t._second;
cout << "Time::Time(const Time&)" << endl;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
private:
// 基本类型(内置类型)
int _year = 1970;
int _month = 1;
int _day = 1;
// 自定义类型
Time _t;
};
int main()
{
Date d1;
// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
Date d2(d1);
return 0;
}
那么编译器默认生成的这种简单值拷贝（浅拷贝）的方式有没有缺陷呢？当然有！
typedef int STDateType;
class Stack
{
public:
//构造函数，显示写一个全缺省的
Stack(int capacity = 4)
{
_a = (STDateType*)malloc(capacity * sizeof(STDateType));
_top = 0;
_capacity = capacity;
}
//编译器默认生成的拷贝构造会这么做：
/*Stack(const Stack& s)
{
_a = s._a;
_top = s._top;
_capacity = s._capacity;
}*/
//析构函数，一定要显示写，否则造成内存泄漏
~Stack()
{
free(_a);
_top = 0;
_capacity = 0;
}
private:
STDateType* _a;
int _top;
int _capacity;
};
int main()
{
Stack s1;
Stack s2(s1);
return 0;
}
我们发现程序直接崩溃了，这是为什呢？
总结来说：
-
涉及资源申请的类一旦使用浅拷贝，两个对象中维护动态开辟空间的指针会一模一样，析构时会对同一块空间重复释放，导致程序崩溃。（这也是C语言中潜在的并无法解决的问题）
-
还有一个问题，就是两个对象的指针都指向同一块空间，一个对象修改空间中的内容会影响到另一个对象，这明显扯淡。
所以:
-
类中一旦涉及到资源申请，拷贝构造函数是一定要写的，否则就是浅拷贝。
那么我们怎么写呢？使用深拷贝!就是重新开辟一块空间，不共用一块空间。
typedef int STDateType;
class Stack
{
public:
//构造函数，显示写一个全缺省的
Stack(int capacity = 4)
{
_a = (STDateType*)malloc(capacity * sizeof(STDateType));
_top = 0;
_capacity = capacity;
}
//编译器默认生成的拷贝构造会这么做：
/*Stack(const Stack& s)
{
_a = s._a;
_top = s._top;
_capacity = s._capacity;
}*/
Stack(const Stack& s)
{
_top = s._top;
_capacity = s._capacity;
_a = (STDateType*)malloc(sizeof(STDateType) * _capacity);
memcpy(_a, s._a, sizeof(STDateType) * _capacity);
}
//析构函数，一定要显示写，否则造成内存泄漏
~Stack()
{
free(_a);
_top = 0;
_capacity = 0;
}
private:
STDateType* _a;
int _top;
int _capacity;
};
int main()
{
Stack s1;
Stack s2(s1);
return 0;
}
-
总结：
-
需要写拷贝构造的：有涉及资源申请的内置类型（指针），如Stack类，我们要写一个深拷贝。
-
不需要写拷贝构造的，编译器默认生成的就可以用：
1.类中全是自定义类型，比如MyQueue类，自动调用Stack的拷贝构造 ；
2.类中全是没有涉及资源申请的内置类型，比如Date类，简单的值拷贝就可以。
-
拷贝构造的使用场景
-
使用已存在对象创建新对象
-
函数参数类型为类类型对象
-
函数返回值类型为类类型对象
-
class Date
{
public:
Date(int year, int minute, int day)
{
cout << "Date(int,int,int):" << this << endl;
}
Date(const Date& d)
{
cout << "Date(const Date& d):" << this << endl;
}
~Date()
{
cout << "~Date():" << this << endl;
}
private:
int _year;
int _month;
int _day;
};
Date Test(Date d)
{
Date temp(d);
return temp;
}
int main()
{
Date d1(2022,1,13);
Test(d1);
return 0;
}
5.赋值运算符重载
5.1 运算符重载 （重要）
C语言中我们想要比较两个结构体，只能写一个函数来比较，而且相比与内置类型可以直接使用==运算符比较，函数比较方式的可读性并不强。
C++为了增强代码的可读性引入了运算符重载，运算符重载可以让自定义类型对象像内置类型变量那样使用运算符，是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表）
注意：
-
不能通过连接其他符号来创建新的操作符：比如operator@。
-
重载操作符必须有一个类类型参数。
-
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义。
-
运算符重载既可以写成全局函数（非必要情况下不建议，因为需要公开成员变量或者使用友元函数，破坏封装），也可以重载成成员函数。
-
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this。
-
重载的运算符有两个操作数时，左操作数是第一个参数（重载成成员函数时，该参数作为this指针被隐藏），右操作数是第二个参数。
-
.*、 ::、 sizeof、 ?:、 . 注意以上5个运算符不能重载。
-
我们重载的运算符一定是一个有意义的运算符，就比如Date类，Date+Date、Date*Date是没有意义的。
-
运算符重载和函数重载没有关系。
我们来重载一下Date类的+=和+运算符
static int daysOfMonth[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
int GetDayOfMonth(int year, int month)
{
if (month == 2 &&
((year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0))))
return 29;
return daysOfMonth[month];
}
Date& Date::operator+=(int days)
{
if (days < 0)
return *this -= (-days);
_day += days;
while (_day > GetDayOfMonth(_year, _month))
{
_day -= GetDayOfMonth(_year, _month);
_month++;
if (_month == 13)
{
_month = 1;
_year++;
}
}
return *this;
}
Date Date::operator+(int days)
{
Date tmp(*this);
tmp += days;
return tmp;
}注意：
-
运算符重载的参数建议都传引用，如果不修改参数，最好传const引用：const Date& d。
-
+=也有返回值，因为C语言的+=支持a += b += 10;这种写法。
-
+=我们返回的是*this， *this就是调用函数的对象，出了函数作用域还在，可以用引用返回。
-
+运算符可以复用+=运算符，使用+时对象不改变，所以拷贝构造一个临时对象tmp来复用+=，tmp是局部对象，出了作用域销毁，必须使用传值返回。
-
+=也可以复用+，这两种复用方式的效率不同，+=复用+如下：
Date Date::operator+(int days)
{
Date tmp(*this);
tmp._day += days;
while (tmp._day > GetDayOfMonth(tmp._year, tmp._month))
{
tmp._day -= GetDayOfMonth(tmp._year, tmp._month);
tmp._month++;
if (tmp._month == 13)
{
tmp._month = 1;
tmp._year++;
}
}
return tmp;
}
Date& Date::operator+=(int days)
{
*this = *this + days;
return *this;
}+复用+=时+会有两次拷贝（拷贝tmp一次，传值返回一次），+=复用+时+=会有三次拷贝（+有两次，赋值重载会有一次）。
5.2 赋值运算符重载
谈论两种问题：
-
赋值运算符重载和拷贝构造函数的区别？
拷贝构造是用一个已经存在的对象去初始化一个新的对象，而赋值运算符重载是两个已经存在的对象进行赋值操作。
-
赋值运算符重载有没有返回值？
有没有返回值就取决于C语言的=运算符有没有返回值，C语言支持连续赋值，=其实是有返回值的，所以赋值运算符重载有返回值。
Date& operator=(const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}注意一点，就是避免自己给自己赋值，直接比较指针即可。
赋值运算符重载也就默认成员函数之一，其它特性和拷贝构造一模一样：
-
参数是对本类类型对象的引用(一般常用const修饰)，返回值是T&。
-
我们不写，编译器默认生成一个赋值运算符重载；默认生成的赋值运算符重载针对内置类型是按照字节方式直接拷贝的，针对自定义类型去调用自定义类型的赋值运算符重载。
-
类中一旦涉及到资源申请，赋值运算符重载我们要自己写个深拷贝。
-
赋值运算符只能重载成类的成员函数不能重载成全局函数。
原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。
5.3 Date类的其他运算符重载
-
-=和-：
Date& Date::operator-=(int days)
{
if (days < 0)
return *this += (-days);
_day -= days;
while (_day <= 0)
{
_month--;
if (_month == 0)
{
_month = 12;
_year--;
}
_day += GetDayOfMonth(_year, _month);
}
return *this;
}
Date Date::operator-(int days)
{
Date tmp(*this);
tmp -= days;
return tmp;
}-
前置++和后置++：
-
前置++和后置++如何区分？后置++使用一个占位参数int来和前置++作区分，这个参数只是一个类型，没有实际意义。
-
后置++返回++前的值，但本身还是要++的，所以我们拷贝构造一个对象做临时值，*this自己复用+=1，然后返回我们保存的临时值。
-
//前置++
Date& Date::operator++()
{
*this += 1;
return *this;
}
//后置++
Date Date::operator++(int)
{
Date tmp(*this);
*this += 1;
return tmp;
}-
前置--和后置--：
同++
Date& Date::operator--()
{
*this -= 1;
return *this;
}
Date Date::operator--(int)
{
Date tmp(*this);
*this -= 1;
return tmp;
}-
-运算符（Date-Date）：
int Date::operator-(const Date& d)
{
// 假设左大右小
int flag = 1;
Date max = *this;
Date min = d;
// 假设错了，左小右大
if (*this < d)
{
max = d;
min = *this;
flag = -1;
}
int n = 0;
while (min != max)
{
++min;
++n;
}
return n * flag;
}-
比较运算符：
比较运算符我们只需要实现==和>，其他运算符复用这两个即可。
bool Date:: operator==(const Date& d)
{
if (_year != d._year)
return false;
if (_year == d._year && _month != d._month)
return false;
if (_year == d._year && _month == d._month && _day != d._day)
return false;
return true;
}
bool Date:: operator!=(const Date& d)
{
return !(*this == d);
}
bool Date:: operator>(const Date& d)
{
if (_year > d._year)
return true;
if (_year == d._year && _month > d._month)
return true;
if (_year == d._year && _month == d._month && _day > d._day)
return true;
return false;
}
bool Date:: operator>=(const Date& d)
{
return (*this == d) || (*this > d);
}
bool Date:: operator<(const Date& d)
{
return !(*this >= d);
}
bool Date:: operator<=(const Date& d)
{
return !(*this > d);
}-
<<和>>运算符：
我们要打印Date类的对象d，不能总是使用d.Print()，Date类能不能重载<<和>>运算符，实现使用控制台cout和cin来打印和修改对象？
void Date::operator<<(ostream& out)
{
out << _year << ":" << _month << ":" << _day << endl;
}这是我们把<<运算符重载成成员函数，发现有以下两个问题：
-
运算符重载我们写成成员函数时，第一个参数是隐藏的this指针，指向要打印的对象d，而第一个参数是左操作数，所以这种情况下我们要这么使用重载的运算符：d<
-
确定<<重载没有返回值？如果连续<<呢？所以我们要返回ostream类的对象out。
问题又来了，我们重载成全局函数，不能访问Date类的私有成员了：
这里有两种解决办法：1、成员变量公开 2、使用友元函数
所谓友元函数，就是该函数是类的朋友，函数就能访问类中的私有成员了。
class Date
{
public:
//...
//友元函数
friend ostream& operator<<(ostream& out, const Date& d);//cout << d1
friend istream& operator>>(istream& in, Date& d);//cin >> d1
private:
//...
};
ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << ":" << d._month << ":" << d._day << endl;
return out;
}
istream& operator>>(istream& in, Date& d)
{
in >> d._year >> d._month >> d._day;
return in;
}注意：重载>>，我们要修改d对象，所以不能加const。
前四种成员函数总结：
6.const成员函数
我们知道，普通的成员函数，内部的this指针类型是（假设为Date类）Date* const this，那么这种成员函数const对象能使用吗？明显不可以！因为普通成员函数的this指向的是非const对象，const对象使用就涉及权限放大问题。
就比如这里的==运算符重载，const对象d1作为左操作数时，他的地址会传给this，this的类型是 Date* const this，涉及权限放大。
如何让const对象也能使用成员函数呢？这就要介绍const成员函数了：
在函数后加const修饰的“成员函数”称之为const成员函数；const修饰类成员函数，实际修饰的是*this，也就是this指针指向的对象。此时this的类型变成const Date * const this 。
bool Date:: operator==(const Date& d) const
{
if (_year != d._year)
return false;
if (_year == d._year && _month != d._month)
return false;
if (_year == d._year && _month == d._month && _day != d._day)
return false;
return true;
}
注意：
-
非const对象也能使用const成员函数，因为这只涉及权限缩小。但是如果同时存在const成员函数和普通成员函数，非const对象优先使用普通成员函数。
Date Date::operator+(int days) const { cout << "Date Date::operator+(int days) const" << endl; Date tmp(*this); tmp += days; return tmp; } Date Date::operator+(int days) { cout << "Date Date::operator+(int days)" << endl; Date tmp(*this); tmp += days; return tmp; }
-
并不是所有成员函数我们都无脑加const，就比如+=、-=、++、--，这明显不能写成const成员函数，因为我们要修改*this，而且const对象根本不能使用以上运算符。
-
const只能修饰成员函数，不能修饰全局函数。因为const修饰的是*this，没有this指针不是扯淡吗？
7.取地址及const取地址操作符重载
class Date
{
public :
Date* operator&()
{
return this ;
}
const Date* operator&() const
{
return this ;
}
private :
int _year ;
int _month ;
int _day ;
}-
这两个函数构成重载，一个参数是Date*，另一个参数是const Date *。
-
这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容。
小Tip：&d转化成 d.operator&(&d);&d不是会无限调用吗？答案是：不会！因为编译器底层并不会加上这个形参&d，他是直接把对象的地址放入寄存器中。