类和对象(中)（二）-阿里云开发者社区

2. 操作符 ==

1. 错误写法

#include<iostream>
using namespace std;
class date
{
public:
  date(int year = 1, int month = 1, int day = 1)//构造
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
//private://需要将_year等改为public
  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(2022,12,21);
  date d2(2022,12,22);
  d1 == d2;
  cout << (d1 == d2) << endl;// 0 代表假
  return 0;
}

第一个参数作为左操作数，第二个参数作为右操作数

这样写看起来是对的，但是这种方法会把date类中私有的成员变量变成共有的，破坏类的封装，不符合我们本意

2. 正确写法

写入类中作为成员函数

#include<iostream>
using namespace std;
class date
{
public:
  date(int year = 1, int month = 1, int day = 1)//构造
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
  bool operator ==( const date& d2)// 由于隐藏的this指针的存在，&d1传过来由this指针接收
  {
    return _year == d2._year && _month == d2._month && _day == d2._day;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  date d1(2022,12,21);
  date d2(2022,12,22);
  d1 == d2;//  d1.operator==(d2) 等价于 d1.operator==(&d1,d2)
  cout << (d1 == d2) << endl;
  return 0;
}

传入类中，由于隐藏的this指针的存在，取第一个参数d1的地址传过去被this指针接收，_year等价于d1._year

但是由于this指针是隐藏的，所以&d1也不需要表现出来直接传入d2即可

3. cout << d1 == d2<< endl; 报错问题

运算符优先级问题，<<代表流插入，<<优先级比==高，所以会先执行cout<<d1 ，剩余的 = =d2无法执行，就会报错

3. 注意事项

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

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

3.用于内置类型的操作符，其含义不能改变(如 int 加法不能改变)

所以要改成 (d1= =d2)来保证d1与d2先执行
这里理解很简单，因为运算符重载是针对自定义类型的，对于内置类型，编译器都已经设置好了

4.作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参

这里理解很简单，因为运算符重载是针对自定义类型的，对于内置类型，编译器都已经设置好了

4.作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参

4. 操作符 >

#include<iostream>
using namespace std;
class date
{
public:
  date(int year = 1, int month = 1, int day = 1)//构造
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
  bool operator >( const date& d2)// 由于隐藏的this指针的存在，&d1传过来由this指针接收
  {
    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()
{
  date d1(2022,12,21);
  date d2(2022,12,22);
  d1 > d2;//等价于 operator>(&d1,d2)
  cout << (d1 > d2) << endl;
  return 0;
}

判断大于时，同样存在一个隐藏的this指针，我们只需要判断年大的就为大，年相等，月大的就为大，年月相等，天大的就为大，其他情况都为假

5. 操作符 !=

#include<iostream>
using namespace std;
class date
{
public:
  date(int year = 1, int month = 1, int day = 1)//构造
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
  bool operator==(const date& d2)//d1==d2
  {
    return _year == d2._year && _month == d2._month && _day == d2._day;
  }
  bool operator!=(const date& d2)
  {
    return !(*this == d2);//借助上面的d1==d2的相反即 d1!=d2
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  date d1(2022,12,21);
  date d2(2022,12,22);
  d1 != d2;
  cout << (d1 != d2) << endl;
  return 0;
}

借助上面已经写好的d1==d2 ，取其相反即为 d1!=d2

6. 操作符 <

#include<iostream>
using namespace std;
class date
{
public:
  date(int year = 1, int month = 1, int day = 1)//构造
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
  bool operator >(const date& d2)// d1>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;
    }
  }
  bool operator<(const date& d2)// d1 < d2
  {
    return !(*this > d2);
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  date d1(2022,12,21);
  date d2(2022,12,22);
  d1 < d2;
  cout << (d1 < d2) << endl;
  return 0;
}

若直接写d1<d2 的条件太复杂，直接采用 d1 >d2 的相反，*this 代表 d1

2 .赋值操作符(编译器默认实现)

1. 正常使用

#include<iostream>
using namespace std;
class date
{
public:
  date(int year = 1, int month = 1, int day = 1)//构造
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
  void operator=(const date& d2)
  {
    //为了防止自己给自己赋值的事情发生，如:d1=d1
    if ( this != &d2)
    {
      _year = d2._year;
      _month = d2._month;
      _day = d2._day;
    }
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  date d1(2022,12,21);
  date d2(2022,12,22);
  d1 =d2;
  return 0;
}

如果是单个赋值这样就符合了，但是还是有连续赋值的情况存在

2. 连续赋值情况的考虑

#include<iostream>
using namespace std;
class date
{
public:
  date(int year = 1, int month = 1, int day = 1)//构造
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
  date operator=(const date& d)//传值返回 类型为date
  {
    //为了防止自己给自己赋值的事情发生，如:d1=d1
    if (this != &d)
    {
      _year = d._year;
      _month = d._month;
      _day = d._day;
    }
    return *this;
  }
  date(const date& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  date d1(2022, 12, 21);
  date d2(d1);
  date d3;
  d2 = d3 = d1;
  int i = 0;
  int j = 0;
  int z = 0;
  i = j = z;
  return 0;
}

如果为内置类型，如int 则可以进行连续赋值
对于int 来说，根据结合性，j=z ,返回值为j ，i=j，生成最终结果i
对于 d2=d3=d1自定义类型来说，将 d1赋值给d3，将其返回值作为d2= 的右操作数存在
所以operator= 要有一个返回值

传值返回

由于*this为date 类型，属于传值返回，即返回一个临时变量，所以需进行拷贝构造

同时也会多开辟一块空间存储，就会导致当return ( * this) 返回时，传入拷贝构造中创建临时变量，再次从中返回时，才能返回到主函数中

传引用返回

传 * this的引用作为变量的别名，相当于 * this本身，不会消耗一块空间，自然在return*this 返回时，不会进入拷贝构造中，而是直接返回

所以传引用返回更优

5. const成员

1.对象调用const成员函数

#include<iostream>
using namespace std;
class date
{
public:
  void print()
  {
    cout << _a << endl;
  }
private:
  int _a;
};
int main()
{
  const date a;
  a.print();//权限放大，会报错
  return 0;
}

将&a传过去由this指针接收， a指针类型为 const date* ，this指针类型为 date* ，将const date * 传给date * 属于权限的放大
把this指针类型改成 const date* 就可以了，但是由于this指针是隐藏的，要怎么解决呢？

#include<iostream>
using namespace std;
class date
{
public:
  void print()const //this指针类型变为const date*
  {
    cout << _a << endl;
  }
private:
  int _a;
};
int main()
{
  const date a;
  a.print();//正确 权限保持
  return 0;
}

在括号外面加上const，使this指针类型改成 const date*

const 在*左右对于指针的影响

const date* p1 ：修饰的是* p1, const在 * 左面指针所指向的内容不变

date const * p2 : 修饰的是* p2，const在* 左面指针所指向的内容不变

date * const p3 : 修饰的是 p3，const在 * 右面，指针本身不变

注意事项

#include<iostream>
using namespace std;
class date
{
public:
  void print()const //this指针类型变为const date*
  {
     _a=10;//报错
    cout << _a << endl;
  }
private:
  int _a;
};
int main()
{
  const date a;
  a.print();//正确 权限保持
  return 0;
}

若在print函数内部修改成员变量_a的值就会报错，_a代表this->_a，但是由于 this指针当前类型为 const date *，使this指向的内容不变

2.成员函数调用const成员函数

#include<iostream>
using namespace std;
class date
{
public:
  void f1()
  {
    f2();
  }
  void f2()const
  {
  }
private:
  int _a;
};
int main()
{
  date a;
  a.f1();
  return 0;
}

在f1中时，this指针的类型为 date*

进入 f2后， this指针转换为 const date *

属于权限缩小，可以实现

#include<iostream>
using namespace std;
class date
{
public:
  void f3()
  {
  }
  void f4()const
  {
    f3();
  }
private:
  int _a;
};
int main()
{
  date a;
  a.f4();
  return 0;
}

f4中 this指针类型为 const date*

f3中 this指针类型为 date*

权限放大了，不可以实现

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

#include<iostream>
using namespace std;
class date
{
public:
  date* operator&()
  {
    return this;
  }
  const date* operator&()const
  {
    return this;
  }
};
int main()
{
  date d;
  cout << &d << endl;
  return 0;
}

类和对象(中)（二）

2. 操作符 ==

1. 错误写法

2. 正确写法

3. cout << d1 == d2<< endl; 报错问题

3. 注意事项

4. 操作符 >

5. 操作符 !=

6. 操作符 <

2 .赋值操作符(编译器默认实现)

1. 正常使用

2. 连续赋值情况的考虑

传值返回

传引用返回

5. const成员

1.对象调用const成员函数

注意事项

2.成员函数调用const成员函数

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

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

类和对象(中)（二）

2. 操作符 ==

1. 错误写法

2. 正确写法

3. cout << d1 == d2<< endl; 报错问题

3. 注意事项

4. 操作符 >

5. 操作符 !=

6. 操作符 <

2 .赋值操作符(编译器默认实现)

1. 正常使用

2. 连续赋值情况的考虑

传值返回

传引用返回

5. const成员

1.对象调用const成员函数

注意事项

2.成员函数调用const成员函数

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

热门文章

最新文章

相关课程

相关电子书

相关实验场景