c++类与对象- - -赋值运算符重载，const特性详解

---

1.赋值运算符重载

1.1 运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

注意：
**1.不能通过连接其他符号来创建新的操作符：比如operator@
2.重载操作符必须有一个类类型或者枚举类型的操作数
3.用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义
4.作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参。

5.** .* *、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现

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;
 }
 //下面这个不能通过，因为含有this指针
 /*bool operator==(const Date& d1, const  Date& d2)
 {
 return  d1._year == d2._year
 &&d1._month == d2._month
 &&d1._day == d2._day;
 }*/
 //d1.operator==(&d1,d2)
 bool operator==(const Date& d)//隐含的this指针
 {
  return  _year == d._year
   &&_month == d._month
   &&_day == d._day;
 }
private:
 int _year;
 int _month;
 int _day;
};
//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;
 Date d2(d1);
 Date d3 = d1;
 d1.print();
 d2.print();
 d1 == d2;//下面一样的
 d1.operator==(d2);//当作为成员函数
 //operator==(d1, d2);//在类外
 return 0;
}

1.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& 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;
};

上下图对比：你会发现什么问题？

//如果就是Date& operator=(const Date& d)不带&就会有拷贝构造产生了
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;
  cout << "Date()" << endl;
 }
 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;
 Date d2(2008, 1, 1);
 d1 = d2;
 d1.print();
 d2.print();
 return 0;
}
输出：
Date()
Date()
200811
200811

赋值运算符主要有四点：
1.参数类型
2.返回值
3.检测是否自己给自己赋值
4.返回*this
5.一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝(浅拷贝)。

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;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d1;
 Date d2(2018, 10, 1);
 // 这里d1调用的编译器生成operator=完成拷贝，d2和d1的值也是一样的。
 d1 = d2;
 d1.print();
 d2.print();
 return 0;
}

那么编译器生成的默认赋值重载函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
class String
{
public:
 String(const char* str = "")
 {
  _str = (char*)malloc(strlen(str) + 1);
  strcpy(_str, str);
 }
 ~String()
 {
  cout << "~String()" << endl;
  free(_str);
 }
private:
 char* _str;
};
int main()
{
 String s1("hello");
 String s2("world");
 s1 = s2;
 return 0;
}

2.const成员

2.1 const修饰类的成员函数

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

class Date
{
public:
 void Display()
 {
  cout << "Display()" << endl;
  cout << "year:" << _year << endl;
  cout << "month:" << _month << endl;
  cout << "day:" << _day << endl << endl;
 }
 void Display()const
 {
  cout << "Display()const" << endl;
  cout << "year:" << _year << endl;
  cout << "month:" << _month << endl;
  cout << "day:" << _day << endl << endl;
 }
private:
 int _year;
 int _month;
 int _day;
};
void test()
{
 Date d1;
 d1.Display();
 const Date d2;
 d2.Display();
}
int main()
{
 test();
 return 0;
}

请思考下面的几个问题：
1.const对象可以调用非const成员函数吗？0
2.非const对象可以调用const成员函数吗？1
3.const成员函数内可以调用其它的非const成员函数吗？0
4.非const成员函数内可以调用其它的const成员函数吗？1

3.取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成

class Date
{
public:
 Date* operator&()
 {
  return this;
 }
 const Date* operator&()const
 {
  return this;
 }
private:
 int _year;
 int _month;
 int _day;
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容