C++入门3——类与对象2-2（类的6个默认成员函数）-阿里云开发者社区

5.赋值运算符重载函数

5.1运算符重载函数

在学习赋值运算符重载之前，我们先来了解一下运算符重载：

通过上面的学习，我们已经知道了内置类型和自定义类型的区别，思考这样一个问题：

显而易见，内置类型对象可以直接用各种运算符，内置类型是语言自己定义的，编译直接转换成指令

举个简单的例子，内置类型的int类型2和1，编译器可以轻松知道2>1；内置类型的double类型2.2和1.1,编译器轻松知道2.2>1.1,诸如此类......

那么问题来了，我们通篇写的Data类对象，我这时候需要判断2012年7月7日与2013年7月7日哪个日期更大，编译器能直接判断出2012年7月7日<2013年7月7日吗？显然是不能的！因为自定义类型编译器不支持直接转换成指令。

那么这时候就需要我们自己写一个函数来实现：

写一个大于比较函数：

bool Greater(Data d1, Data d2)
{
  if (d1._year > d2._year)
  {
    return true;
  }
  else if (d1._year == d2._year && d1._month > d2._month)
  {
    return true;
  }
  else if (d1._year == d2._year && d1._month ==d2._month && d1._day > d2._day)
  {
    return true;
  }
    return false;
}

再比如我写一个等于比较的函数：

bool Equal(Data d1, Data d2)
{
  return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}

运行一下：

#include <iostream>
using namespace std;
class Data
{
public:
  Data(int year = 2012, int month = 7, int day = 7)
  {
    _year = year;
    _month = month;
    _day = day;
  }
 
  Data(const Data& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
  }
 
  void Ptint()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
 
//private:
  int _year;
  int _month;
  int _day;
};
 
//布尔类型（bool）用于表示真（true）和假（false）的值。
//它只有两个取值：true 和 false，分别对应 1 和 0 。
bool Greater(Data d1, Data d2)
{
  if (d1._year > d2._year)
  {
    return true;
  }
  else if (d1._year == d2._year && d1._month > d2._month)
  {
    return true;
  }
  else if (d1._year == d2._year && d1._month ==d2._month && d1._day > d2._day)
  {
    return true;
  }
    return false;
}
 
bool Equal(Data d1, Data d2)
{
  return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}
 
int main()
{
  Data d1(2013, 7, 7);
  Data d2(2012, 7, 7);
  cout << Greater(d1, d2) << endl;
  cout << Equal(d1, d2) << endl; 
  return 0;
}

说到这里，我们来说一个题外话，关于函数的命名，其实在C语言中我们就遇到过很多了，一个函数命名就如同给自己的孩子取名字一样，比如上面的判断大于和判断相等函数，我能用Greater、Equal，为什么就不能用DaYu、DengYu，或者Compare1、Compare2，又或者func1、func2呢？

这些确实都是可以的呀！我创建的函数，我乐意怎样取名我就怎样取名！

可是话说回来，你的孩子在你口中叫狗蛋儿、在老师口中叫张三，有一天你去开家长会，老师问你是谁的家长，你说你是狗蛋儿的家长，你这样说老师会知道张三就是狗蛋儿，狗蛋儿就是张三吗？

话再说回来，你写的函数叫DaYu、DengYu，而你的同事要用这个函数，你写的DaYu、DengYu，同事能知道这是个什么函数吗？

所以，为了规避这种情况，增强代码的可读性，C++引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

因此上述两个函数就可以写为（更加规范，我们加上const和&）：

//bool Greater(Data d1, Data d2)
bool operator>(const Data& d1, const Data& d2)
{
  if (d1._year > d2._year)
  {
    return true;
  }
  else if (d1._year == d2._year && d1._month > d2._month)
  {
    return true;
  }
  else if (d1._year == d2._year && d1._month ==d2._month && d1._day > d2._day)
  {
    return true;
  }
    return false;
}
 
//bool Equal(Data d1, Data d2)
bool operator == (const Data& d1, const Data& d2)
{
  return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}

int main()
{
  Data d1(2013, 7, 7);
  Data d2(2012, 7, 7);
  /*cout << Greater(d1, d2) << endl;
  cout << Equal(d1, d2) << endl; */
  cout << operator > (d1, d2) << endl;
  cout << operator == (d1, d2) << endl;
  return 0;
}

以及为了令自定义类型更贴合与内置类型一样让编译器自己计算，直接转为指令：

int main()
{
  Data d1(2013, 7, 7);
  Data d2(2012, 7, 7);
  /*cout << Greater(d1, d2) << endl;
  cout << Equal(d1, d2) << endl; */
  /*cout << operator > (d1, d2) << endl;
  cout << operator == (d1, d2) << endl;*/
 
  bool ret1 = d1 > d2;   //d1>d2吗？是为1，否为0；
  bool ret2 = d1 == d2;  //d1=d2吗？是为1，否为0；
  int a = 3 > 2;         //3>2吗？是为1，否为0；
  int b = 3 == 2;        //3=2吗？是为1，否为0；
  cout << ret1 << endl << ret2 << endl;
  cout << a << endl << b << endl;
  return 0;
}

仔细观察我们上面写的Data类，可以发现我把private注释掉了，那现在我把注释关掉：

成员变量变私有了该怎么办呢？其实C++常用的解决方法是直接将函数放到类里面，因为类里面可以随便访问private：

class Data
{
public:
  Data(int year = 2012, int month = 7, int day = 7)
  {
    _year = year;
    _month = month;
    _day = day;
  }
 
  Data(const Data& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
  }
 
  
  bool operator == (const Data& d1, const Data& d2)
  {
    return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
  }
 
  void Ptint()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
 
private:
  int _year;
  int _month;
  int _day;
};

可是这样写发现还是编译不通过：

它说函数参数太多？！我放到类外面参数就不多，怎么放到类里面就多参数了呢？

对！因为存在一个隐含的this指针（详细请看C++入门2——类与对象（1）中的3），所以这时就可以这样修改：

class Data
{
public:
  Data(int year = 2012, int month = 7, int day = 7)
  {
    _year = year;
    _month = month;
    _day = day;
  }
 
  Data(const Data& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
  }
 
  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;
    }
    return false;
  }
 
  bool operator == ( const Data& d2)
  {
    return _year == d2._year && _month == d2._month && _day == d2._day;
  }
 
  void Ptint()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
 
private:
  int _year;
  int _month;
  int _day;
};

那么在函数调用时，编译器就会帮我们负重前行：

int main()
{
  Data d1(2013, 7, 7);
  Data d2(2012, 7, 7);
 
  bool ret1 = d1 > d2;    //d1.operator>(d2)--->d1.operator>(&d1,d2)
  bool ret2 = d1 == d2;   //d1.operator==(d2)--->d1.operator==(&d1,d2)
  
  cout << ret1 << endl << ret2 << endl;
  return 0;
}

所以运算符重载归纳有以下特点：

1. 不能通过连接其他符号来创建新的操作符：比如operator@；

2. 重载操作符必须有一个类类型参数；

3. 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义；

4. 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this；

5. .* :: sizeof ?: . 以上5个运算符不能重载。

5.2 赋值运算符重载函数

铺了那么多前戏，终于来到我们要学习的赋值运算符重载函数了：

我们知道，拷贝构造就是将一个已经初始化的变量A拷贝到未初始化的变量B中，

那么如果存在两个都已经初始化的变量A、B，我想把A的值拷贝到B，显然就不能再用拷贝构造了，要用到我们就要开始讲的赋值运算符重载：

1. 赋值运算符重载格式：

参数类型：const T&，传递引用可以提高传参效率

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值检测是否自己给自己赋值

返回*this ：要复合连续赋值的含义

（详解精华都在代码里）：

#include <iostream>
using namespace std;
class Data
{
public:
  Data(int year = 2012, int month = 7, int day = 7)
  {
    _year = year;
    _month = month;
    _day = day;
  }
 
  Data(const Data& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
  }
  //d1=d2;d1传给this，d2传给d
  //返回值应该是什么类型呢？当然是Data类型；应该返回d1的地址，所以用&引用返回
  Data& operator=(const Data& d)
  {
    //判断是否为自己给自己赋值，&放到这里不是引用，是取地址：
    //判断d2的地址是否与d1地址相等
    if (this != &d)
    {
      _year = d._year;
      _month = d._month;
      _day = d._day;
    }
    return *this;//返回d1的地址
  }
 
  void Ptint()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
 
private:
  int _year;
  int _month;
  int _day;
};
 
int main()
{
  Data d1(2023, 7, 7);
  Data d2(2022, 8, 8);
  //拷贝构造：一个已经存在的对象去拷贝初始化另一个对象
  Data d3(d2);
  d1.Ptint();
  d2.Ptint();
  d3.Ptint();
  cout << endl;
  //赋值运算符重载：两个已经存在的对象拷贝
  d1 = d2;//运算自定义类型，就要用到运算符重载operator=
  d1.Ptint();
  d2.Ptint();
  d3.Ptint();
}

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

4.如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

这些特性与拷贝构造函数有极大的相似性，这里不再过多赘述。

5.3 前置++和后置++重载

在C语言中，我们已经知道了：前置++，先加后用；后置++，先用后加 这样的基本常识

那么我们学了运算符重载，现在我要自定义类型Data前置++和后置++，要怎么定义和实现呢？

前置++：

前置++为先+1后使用；所以前置++的返回值应该是返回+1之后的结果；

故前置++重载函数的实现为：

// 前置++：返回+1之后的结果
  Date& operator++()//返回d1，所以返回值类型当然为Date类型
  {
    _day += 1;
    return *this;//this指向的对象函数结束后不会销毁，故以&引用方式返回提高效率
  }

后置++：

后置++为先使用后+1；所以后置++的返回值应该为+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1；

那么问题来了，前置++和后置++都是一元运算符，实现起来两个函数名字相同，都是operator++，怎么才能区分这两个函数呢？

为了让前置++与后置++形成能正确重载，C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递

故后置++重载函数的实现为：

  Date operator++(int)
  {
    Date temp(*this);// 先将this保存一份，然后给this + 1
    _day += 1;
    return temp;    // temp是临时对象，出了作用域就会被销毁，
                        //因此只能以值的方式返回，不能返回引用
  }

验证：

#include <iostream>
using namespace std;
class Date
{
public:
  Date(int year = 2023, int month = 7, int day = 7)
  {
    _year = year;
    _month = month;
    _day = day;
  }
    // 前置++：返回+1之后的结果
  Date& operator++()//返回d1，所以返回值类型当然为Date类型
  {
    _day += 1;
    return *this;//this指向的对象函数结束后不会销毁，故以&引用方式返回提高效率
  }
  Date operator++(int)
  {
    Date temp(*this);// 先将this保存一份，然后给this + 1
    _day += 1;
    return temp;    // temp是临时对象，出了作用域就会被销毁，
                        //因此只能以值的方式返回，不能返回引用
  }
    void Print()
    {
      cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  Date d2(2022, 7, 7);
  d1 = ++d2;//前置++，编译器默认调用不带（int）参数的operator++
  d1.Print();
  d1 = d2++;//后置++，编译器默认调用带（int）参数的operator++
  d1.Print();
  return 0;
}

小知识：在C语言中前置++和后置++二者的效率高低可能并不明显，但是在C++中，一般来说前置++的效率要高于后置++

6.（&）取地址操作符重载函数和const取地址操作符重载函数

6.1 const成员

终于来到类的最后两个默认成员成员函数了，在介绍最后两个默认成员函数之前，我们先来了解一下什么是const成员：

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

编译器对const成员的处理：

6.2 取地址及const取地址操作符重载

二者的形式为：

class Date
{
public:
  //（&）取地址操作符重载
  Date* operator&()
  {
    return this;
  }
 
  //const（&）取地址操作符重载
  const Date* operator&()const
  {
    return this;
  }
private:
  int _year; // 年
  int _month; // 月
  int _day; // 日
};

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

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！所以这里就不再过多介绍这两个默认成员函数。

（本篇完）

C++入门3——类与对象2-2（类的6个默认成员函数）

5.赋值运算符重载函数

5.1运算符重载函数

5.2 赋值运算符重载函数

5.3 前置++和后置++重载

前置++：

后置++：

6.（&）取地址操作符重载函数和const取地址操作符重载函数

6.1 const成员

6.2 取地址及const取地址操作符重载

热门文章

最新文章

相关课程

相关电子书

相关实验场景