首页
学习
活动
专区
圈层
工具
发布
社区首页 >专栏 >C++:12---运算符重载

C++:12---运算符重载

作者头像
网易架构师高司机
发布于 2021-02-03 15:34:35
发布于 2021-02-03 15:34:35
1.1K0
举报
文章被收录于专栏:游戏开发司机游戏开发司机

一、概念

  • 对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型
  • 重载的运算符是具有特殊名字的函数,该函数也有返回值、参数列表、函数体

二、运算符重载的3种实现方式

  • 成员函数:私有、公有、保护都可以
  • 友元函数:同上
  • 全局函数:只能访问公有的

三、运算符重载的规则

C++98,C++0x,C++11对“哪些运算符重载能够重载”有一致的规定。详细例如以下:

  • 以下运算符不支持重载:.(类属运算符),::(作用域运算符),sizeof,?:(三目运算符),#(预处理运算符)
  • 只能用成员函数重载的运算符:=(赋值运算符)、()(强制类型转换)、[]、new、delete、->
  • 只能用友元、全局函数重载的运算符:<<、>>
  • +=、-=、=运算符返回值为引用类型(&):函数执行完之后返回的是*this(对象本身)。如果不加&,则返回的是临时对象
  • 承接上一注意事项:前置++、--,返回值为引用。后置++、--,返回值不为引用

四、+、-、*、/、+=、-=的重载

  • //只实现+、*,+=。其它原理都相同
代码语言:javascript
复制
class Cperson
{
private:
int data;
public:
Cperson operator+(Cperson const& other)const;//类成员函数实现
friend Cperson operator*(Cperson const& p1,Cperson const& p2);//友元函数方式实现
Cperson& operator+=(Cperson const& other);
};
Cperson Cperson::operator+(Cperson const& other)const
{
Cperson temp;
temp.data=this->data+other.data;
return temp;
}

Cperson operator*(Cperson const& p1,Cperson const& p2)
{
Cperson temp;
temp.data=p1.data*p2.data;
return temp;
}

Cperson& Cperson::operator+=(Cperson const& other)
{
Cperson temp=*this=other;//因为前面已经实现了+运算符,此处直接使用
return *this=temp;
}

五、 赋值运算符(=)的重载

  • 赋值运算符的重载,返回值应该为运算符左侧对象的一个引用,否则返回的是一个临时对象
  • 如果没有写赋值重载运算符,编译器自动存在一个默认的,就是拷贝构造中所用到的默认拷贝构造,但是如果类成员变量中含有动态内存的变量时,需要重载赋值运算符
代码语言:javascript
复制
class Cperson
{
private:
char* name;
public:
Cperson& operator=(Cperson const& other);
};
Cperson& Cperson::operator=(Cperson const& other)
{
if(this->name)//先释放原先的数据
delete[] name;
if(other)//如果传入的参数不为空
{
int len=strlen(other.name);
this->name=new char[len+1];
strcpy(this->name,other.name);
}
else//如果传入的参数为空
{
other.name=nullptr;
}
};

拷贝构造函数与拷贝赋值运算符的关系

  • 拷贝构造函数是用另一个对象来初始化一块内存区域,这块内存就是新对象的内存区
  • 赋值函数是对于一个已经被初始化的对象来进行operator=操作。例如:
代码语言:javascript
复制
class A;
A a;
A b = a; // 调用拷贝构造函数, 因为b是第一次初始化
A c(a);  // 调用拷贝构造函数, 因为c是第一次初始化
b = c;   // 调用赋值运算符, 因为b已经初始化过了

六、 ++、--运算符的重载

  • 为了区别前置和后置:后置++的参数为int,前置++无参数
  • 前置++、--,返回值为引用。后置++、--,返回值不为引用
  • ++、--(前置后置),下面只演示++的操作
代码语言:javascript
复制
class Cperson
{
private:
int data;
public:
Cperson& operator++();//前置++,返回值为引用
Cperson operator++(int);//后置++,返回值不为引用
};
Cperson& Cperson::operator++()
{
data++;
return *this;
}
Cperson Cperson::operator++(int)
{
Cperson temp=*this;
data++;
return temp;
}

七、==、!=运算符的重载

  • 用途:这两个运算符用来判断两个类对象中数据成员的值是否相等/不相等(可以在重载中判断单/多个成员是否相等)

设计规则:

  • 通常情况下,==运算符应该具有传递性,例如:如果a==b和b==c,那么a==c应该也为真
  • 如果实现了==运算符,则!=运算符可以直接在return语句中应用刚才实现的==运算符来简化书写
  • 如果用成员函数实现只能有一个参数,用友元、全局函数实现是两个参数
代码语言:javascript
复制
class Cperson
{
private:
int id;
int age;
public:
Cperson(int Id, int Age) :id(Id), age(Age) {}
int getId()const;
int getAge()const;
friend bool operator==(const Cperson &p1, const Cperson &p2)
{
return ((p1.getId() == p2.getId()) && (p1.getAge() == p2.getAge()));
}
friend bool operator!=(const Cperson &p1, const Cperson &p2)
{
return !(p1 == p2);
}
};
int Cperson::getId()const { return id; }
int Cperson::getAge()const { return age; }

八、 >>、<<运算符的重载

  • 输入输出运算符的重载不能用成员函数实现,一般用友元实现

重载输出运算符<<

参数:

  • 参数1:一个非常量ostream对象的引用(ostream是非常量是因为向流写入内容会改变其状态)
  • 参数2:一般来说是一个常量的引用,该常量是我们想要打印的类类型(使用引用的原因是我们希望避免复制实参。使用常量是因为不会改变对象的内容)

返回值:返回它的ostream形参

重载输入运算符>>

参数:

  • 参数1:是运算符将要读取的流的引用
  • 参数2:将要读入到的(非常量)的引用(使用非常量是因为输入运算符本身的目的就是将数据读入到这个对象中)

返回值:某个给定流的引用

输入时可能产生的错误:

  • 输入的类型不符
  • 当读取操作达到文件末尾或者遇到输入流的其它错误时也会失败
代码语言:javascript
复制
class Cpoint
{
private:
int x;
int y;
public:
friend ostream& operator<<(ostream& os, const CMyPoint const& pt);//输出流
friend istream& operator>>(ostream& is, const CMyPoint const& pt);//输入流
}
ostream& operator<<(ostream& os, const CMyPoint const& pt)
{
os<<pt.x<<pt.y;
return os;
}
istream& operator>>(ostream& is,const CMyPoint const& pt)
{
is>>pt.x>>pt.y;
return is;
}

九、[]下标运算符的重载

下标操作符 [] 通常用于访问数组元素。重载该运算符用于增强操作 C++ 数组的功能。

下面的实例演示了如何重载下标运算符 []。

代码语言:javascript
复制
#include <iostream>
using namespace std;
const int SIZE = 10;

class Safearray
{
   private:
      int arr[SIZE];
   public:
      Safearray() 
      {
         register int i;
         for(i = 0; i < SIZE; i++)
         {
           arr[i] = i;
         }
      }
      int& operator[](int i)
      {
          if( i > SIZE )
          {
              cout << "索引超过最大值" <<endl; 
              // 返回第一个元素
              return arr[0];
          }
          return arr[i];
      }
};
int main()
{
   Safearray A; 
   cout << "A[2] 的值为 : " << A[2] <<endl;
   cout << "A[5] 的值为 : " << A[5]<<endl;
   cout << "A[12] 的值为 : " << A[12]<<endl; 
   return 0;
}

十、->成员访问运算符的重载

类成员访问运算符( -> )可以被重载,但它较为麻烦。它被定义用于为一个类赋予"指针"行为。运算符 -> 必须是一个成员函数。如果使用了 -> 运算符,返回类型必须是指针或者是类的对象。

运算符 -> 通常与指针引用运算符 * 结合使用,用于实现"智能指针"的功能。这些指针是行为与正常指针相似的对象,唯一不同的是,当您通过指针访问对象时,它们会执行其他的任务。比如,当指针销毁时,或者当指针指向另一个对象时,会自动删除对象。

间接引用运算符 -> 可被定义为一个一元后缀运算符。也就是说,给出一个类:

代码语言:javascript
复制
classPtr{
   //...
   X *operator->();};

类 Ptr 的对象可用于访问类 X 的成员,使用方式与指针的用法十分相似。例如:

代码语言:javascript
复制
void f(Ptr p ){
   p->m =10;// (p.operator->())->m = 10}

语句 p->m 被解释为 (p.operator->())->m。同样地,下面的实例演示了如何重载类成员访问运算符 ->。

代码语言:javascript
复制
#include <iostream>
#include <vector>
using namespace std;
 
// 假设一个实际的类
class Obj {
   static int i, j;
public:
   void f() const { cout << i++ << endl; }
   void g() const { cout << j++ << endl; }
};
 
// 静态成员定义
int Obj::i = 10;
int Obj::j = 12;
 
// 为上面的类实现一个容器
class ObjContainer {
   vector<Obj*> a;
public:
   void add(Obj* obj)
{ 
      a.push_back(obj);  // 调用向量的标准方法
   }
   friend class SmartPointer;
};
 
// 实现智能指针,用于访问类 Obj 的成员
class SmartPointer {
   ObjContainer oc;
   int index;
public:
   SmartPointer(ObjContainer& objc)
   { 
       oc = objc;
       index = 0;
   }
   // 返回值表示列表结束
   bool operator++() // 前缀版本
   { 
     if(index >= oc.a.size() - 1) return false;
     if(oc.a[++index] == 0) return false;
     return true;
   }
   bool operator++(int) // 后缀版本
   { 
      return operator++();
   }
   // 重载运算符 ->
   Obj* operator->() const 
   {
     if(!oc.a[index])
     {
        cout << "Zero value";
        return (Obj*)0;
     }
     return oc.a[index];
   }
};
 
int main() {
   const int sz = 10;
   Obj o[sz];
   ObjContainer oc;
   for(int i = 0; i < sz; i++)
   {
       oc.add(&o[i]);
   }
   SmartPointer sp(oc); // 创建一个迭代器
   do {
      sp->f(); // 智能指针调用
      sp->g();
   } while(sp++);
   return 0;
}

十一、()函数调用运算符的重载

  • 如果类重载了函数调用运算符,那么我们在使用该对象时就如同调用一个函数一样
  • 注意:()运算符与对象初始化时调用构造函数不是一个东西、因此()函数调用运算符不能再类初始化时使用,会与构造函数冲突
代码语言:javascript
复制
struct absInt {
bool operator()(int value) {
return value < 0 ? true : false;
}
};
int main()
{
absInt a;
printf("%d\n", a(-1));//打印1
return 0;
}
本文参与 腾讯云自媒体同步曝光计划,分享自微信公众号。
原始发表:2020-11-28,如有侵权请联系 cloudcommunity@tencent.com 删除
目录
  • 一、概念
  • 二、运算符重载的3种实现方式
  • 三、运算符重载的规则
  • 四、+、-、*、/、+=、-=的重载
  • 五、 赋值运算符(=)的重载
    • 拷贝构造函数与拷贝赋值运算符的关系
  • 六、 ++、--运算符的重载
  • 七、==、!=运算符的重载
  • 八、 >>、<<运算符的重载
    • 重载输出运算符<<
    • 重载输入运算符>>
  • 九、[]下标运算符的重载
  • 十、->成员访问运算符的重载
  • 十一、()函数调用运算符的重载
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档