第五层:C++中的运算符重载(上)

简介: 第五层:C++中的运算符重载(上)

前情回顾


第四层中,我遇到了一个很新奇的力量,叫做友元,可以把一些人变成好朋友的神奇力量,除此之外,还学习到了,类内声明函数,类外进行定义的操作,同时,也踏入了第五层…


🚄上章地址:第四层:友元与函数成员别样定义


运算符重载


黑黝黝的洞口,一个人影在缓缓出现,“我就知道你肯定可以掌握友元的,这次需要你掌握另一种重载的力量——运算符重载,祝你好运…”。“新的重载吗…”。


概念


对已有的运算符进行重新定义,赋予其另一种功能,以适应各种不同的运算类型


为什么会出现运算符重载


对于内置的数据类型,编译器知道如何运算,但是对于自定义类型,是不知道如何去运算的,这个时候就需要运算符重载,本质上,是写一个函数来告诉编译器。


运算符重载中函数名格式


对于运算符重载中,上面提到,本质上是写一个函数,不同的人对于函数的命名方式是不一样的,这样编译器也不好识辨,这个函数是不是在实现运算符重载,所以编译器提供了一个固定的格式:

operator+(这里这个加号可以替换成别的符号,当你要对什么符号进行运算符重载时就用什么符号)


加减运算符重载


作用


实现两个自定义数据类型的相加减运算


实现


上面提到对于内置数据类型编译器可以知道如何去运算,而自定义类型是不知道的,那现在有一个类,它有三个对象,其中一个对象等于其他两个对象加起来,要怎么实现,可以先验证直接用+能不能进行:


#include<iostream>
using namespace std;
class A
{
public:
  A()
  {
  }
  A(int a, int b)
  {
  _a = a;
  _b = b;
  }
  int _a;
  int _b;
};
void test1()
{
  A a1(10, 10);
  A a2(10, 10);
  A a3;
  a3 = a1 + a2;
}
int main()
{
  test1();
  return 0;
}

0a2653c851af460fa595bd959398a8f1.png

报错了,没有与这些操作数匹配的“+”运算符,这个错误说明了编译器是不知道对象内部怎么进行加减的,那设计一个函数,函数名字用上面提到的operate+:


#include<iostream>
using namespace std;
class A
{
public:
  A()
  {
  }
  A(int a, int b)
  {
  _a = a;
  _b = b;
  }
  A operator+(A &a1)
  {
  A tmp;
  tmp._a = this->_a + a1._a;
  tmp._b = this->_b + a1._b;
  return tmp;
  }
  int _a;
  int _b;
};
void test1()
{
  A a1(10, 10);
  A a2(10, 10);
  A a3;
  a3 = a1 + a2;
  cout << a3._a<<"   "<< a3._b;
}
int main()
{
  test1();
  return 0;
}

0eacb84100b54626af849e6b562bf92a.png

其实这中写法的本质还是调用函数,即:


a3=a1+a2 == a3=a1.operator+(a2)

同时也可以把这个改成类外的全局函数,这个时候传参就需要传两个,内部改一下:


#include<iostream>
using namespace std;
class A
{
public:
  A()
  {
  }
  A(int a, int b)
  {
  _a = a;
  _b = b;
  }
  //A operator+(A &a1)
  //{
  //  A tmp;
  //  tmp._a = this->_a + a1._a;
  //  tmp._b = this->_b + a1._b;
  //  return tmp;
  //}
  int _a;
  int _b;
};
A operator+(A& a1, A& a2)
{
  A tmp;
  tmp._a = a1._a + a2._a;
  tmp._b = a1._b + a2._b;
  return tmp;
}
void test1()
{
  A a1(10, 10);
  A a2(10, 10);
  A a3;
  a3 = a1 + a2;
  cout << a3._a<<"   "<< a3._b;
}
int main()
{
  test1();
  return 0;
}

2d65d23f6d4748949b924e4057485923.png

也是可以正常跑起来的。

减号同理,与加号实现原理一致,只需要把+换成-。


#include<iostream>
using namespace std;
class A
{
public:
  A()
  {
  }
  A(int a, int b)
  {
  _a = a;
  _b = b;
  }
  //A operator+(A &a1)
  //{
  //  A tmp;
  //  tmp._a = this->_a + a1._a;
  //  tmp._b = this->_b + a1._b;
  //  return tmp;
  //}
  int _a;
  int _b;
};
A operator-(A& a1, A& a2)
{
  A tmp;
  tmp._a = a1._a - a2._a;
  tmp._b = a1._b - a2._b;
  return tmp;
}
void test1()
{
  A a1(10, 10);
  A a2(10, 10);
  A a3;
  a3 = a1 - a2;
  cout << a3._a<<"   "<< a3._b;
}
int main()
{
  test1();
  return 0;
}

2e9b90b2ca334476abebe75bafe6eeaa.png


左移运算符重载


作用


可以输出自定义的数据类型


左移运算符是什么?


左移运算为程序员调用cout的时候,会在后面加“<<”,这个就是左移运算符


实现


同样,可以直接用cout来进行只用类就把类内属性都打印出来吗:


#include<iostream>
using namespace std;
class A
{
public:
  A()
  {
  }
  A(int a, int b)
  {
  _a = a;
  _b = b;
  }
  //A operator+(A &a1)
  //{
  //  A tmp;
  //  tmp._a = this->_a + a1._a;
  //  tmp._b = this->_b + a1._b;
  //  return tmp;
  //}
  int _a;
  int _b;
};
A operator-(A& a1, A& a2)
{
  A tmp;
  tmp._a = a1._a - a2._a;
  tmp._b = a1._b - a2._b;
  return tmp;
}
void test1()
{
  A a1(10, 10);
  A a2(10, 10);
  A a3(0, 0);
  a3 = a1 - a2;
  cout << a3 << endl ;
}
int main()
{
  test1();
  return 0;
}

0a2653c851af460fa595bd959398a8f1.png


明显是不可以的,那要怎么样进行改造呢?如果是成员函数呢?传参和返回类型是什么?返回类型暂定为void,那参数呢?cout吗?那传参cout简化就变成了:


对象<

放的顺序不一样,所以成员函数无法实现,那就用全局函数,用之前,需要探究一个事情,cout是什么类型?转到定义看一下:

0eacb84100b54626af849e6b562bf92a.png

cout的类型就是ostream,那类型解决了,还有什么注意事项吗?有,并且很重要:


对于全局来说,只有一个cout,所以cout是需要进行引用的,对象也是需要进行引用才可以。

#include<iostream>
using namespace std;
class A
{
public:
  A()
  {
  }
  A(int a, int b)
  {
  _a = a;
  _b = b;
  }
  //A operator+(A &a1)
  //{
  //  A tmp;
  //  tmp._a = this->_a + a1._a;
  //  tmp._b = this->_b + a1._b;
  //  return tmp;
  //}
  int _a;
  int _b;
};
A operator-(A& a1, A& a2)
{
  A tmp;
  tmp._a = a1._a - a2._a;
  tmp._b = a1._b - a2._b;
  return tmp;
}
void operator<<(ostream& cout, A& a3)
{
  cout << a3._a << "   " << a3._b;
}
void test1()
{
  A a1(10, 10);
  A a2(10, 10);
  A a3(0, 0);
  a3 = a1 - a2;
  cout << a3 << endl;
}
int main()
{
  test1();
  return 0;
}

0a2653c851af460fa595bd959398a8f1.png

为什么这里还是有报错?对于cout这种能一直在后面追加编程,称作链式编程,在前面的this指针中,提到过一种用途,这里也要用到,因为返回的是void,所以对于endl来说,前面的就不是cout,所以就不能进行输出,那这里就需要返回一个cout,cout的类型,同时记得加引用:


#include<iostream>
using namespace std;
class A
{
public:
  A()
  {
  }
  A(int a, int b)
  {
  _a = a;
  _b = b;
  }
  //A operator+(A &a1)
  //{
  //  A tmp;
  //  tmp._a = this->_a + a1._a;
  //  tmp._b = this->_b + a1._b;
  //  return tmp;
  //}
  int _a;
  int _b;
};
A operator-(A& a1, A& a2)
{
  A tmp;
  tmp._a = a1._a - a2._a;
  tmp._b = a1._b - a2._b;
  return tmp;
}
ostream& operator<<(ostream& cout, A& a3)
{
  cout << a3._a << "   " << a3._b;
  return cout;
}
void test1()
{
  A a1(10, 10);
  A a2(10, 10);
  A a3(0, 0);
  a3 = a1 - a2;
  cout << a3 << endl;
}
int main()
{
  test1();
  return 0;
}

0eacb84100b54626af849e6b562bf92a.png


递增递减运算符


作用


通过重载递增递减预算符,实现自己类内的整型数据


实现


前置

前置的递增递减是前++(- -),在使用,所以可以先在实现的函数内部先进行++(- -),在返回引用,这里为什么要返回引用呢?如果不返回引用,那就是对局部这个变量进行了++(- -),多次使用++(- -),本身只会生成一次,因为不是引用,会产生拷贝,把数据拷贝到新的空间上:


使用引用

#include<iostream>
using namespace std;
class A
{
public:
  A()
  {
  }
  A(int a, int b)
  {
  _a = a;
  _b = b;
  }
  A& operator++()
  {
  this->_a++;
  this->_b++;
  return *this;
  }
  //A operator+(A &a1)
  //{
  //  A tmp;
  //  tmp._a = this->_a + a1._a;
  //  tmp._b = this->_b + a1._b;
  //  return tmp;
  //}
  int _a;
  int _b;
};
A operator-(A& a1, A& a2)
{
  A tmp;
  tmp._a = a1._a - a2._a;
  tmp._b = a1._b - a2._b;
  return tmp;
}
ostream& operator<<(ostream& cout, A& a3)
{
  cout << a3._a << "   " << a3._b;
  return cout;
}
void test1()
{
  A a1(10, 10);
  A a2(10, 10);
  A a3(0, 0);
  a3 = a1 - a2;
  cout << ++(++a3) << endl;
}
int main()
{
  test1();
  return 0;
}


0a2653c851af460fa595bd959398a8f1.png

0a2653c851af460fa595bd959398a8f1.png


不使用引用

#include<iostream>
using namespace std;
class A
{
public:
  A()
  {
  }
  A(int a, int b)
  {
  _a = a;
  _b = b;
  }
  A operator++()
  {
  this->_a++;
  this->_b++;
  return *this;
  }
  //A operator+(A &a1)
  //{
  //  A tmp;
  //  tmp._a = this->_a + a1._a;
  //  tmp._b = this->_b + a1._b;
  //  return tmp;
  //}
  int _a;
  int _b;
};
A operator-(A& a1, A& a2)
{
  A tmp;
  tmp._a = a1._a - a2._a;
  tmp._b = a1._b - a2._b;
  return tmp;
}
ostream& operator<<(ostream& cout, A& a3)
{
  cout << a3._a << "   " << a3._b;
  return cout;
}
void test1()
{
  A a1(10, 10);
  A a2(10, 10);
  A a3(0, 0);
  a3 = a1 - a2;
  cout << ++(++a3) << endl;
}
int main()
{
  test1();
  return 0;
}


0eacb84100b54626af849e6b562bf92a.png

直接是报错的。

前置递减实现也相同,将++换成–即可。



相关文章
|
5月前
|
编译器 C++
C++进阶之路:何为运算符重载、赋值运算符重载与前后置++重载(类与对象_中篇)
C++进阶之路:何为运算符重载、赋值运算符重载与前后置++重载(类与对象_中篇)
52 1
|
6月前
|
程序员 编译器 C++
C++中的运算符重载(Operator Overloading)
C++中的运算符重载(Operator Overloading)
60 1
|
2月前
|
C++
C++(十五) 运算符重载
C++中的运算符重载允许对已有运算符的功能进行重新定义,从而扩展语言功能、简化代码并提升效率。重载遵循特定语法,如 `friend 类名 operator 运算符(参数)`。重载时需注意不可新增或改变运算符数量、语义、优先级、结合性和返回类型。常见示例包括双目运算符 `+=` 和单目运算符 `-` 及 `++`。输入输出流运算符 `&lt;&lt;` 和 `&gt;&gt;` 也可重载。部分运算符只能作为成员函数重载。
|
5月前
|
存储 编译器 C++
【C++】:拷贝构造函数和赋值运算符重载
【C++】:拷贝构造函数和赋值运算符重载
30 1
|
5月前
|
C++ 索引
C++核心技术要点《运算符重载》
C++核心技术要点《运算符重载》
53 2
|
4月前
|
自然语言处理 程序员 C++
C++基础知识(五:运算符重载)
运算符重载是C++中的一项强大特性,它允许程序员为自定义类型(如类或结构体)重新定义标准运算符的行为,使得这些运算符能够适用于自定义类型的操作。这样做可以增强代码的可读性和表达力,使得代码更接近自然语言,同时保持了面向对象编程的封装性。
|
4月前
|
Java 程序员 C++
|
4月前
|
编译器 C++
【C++】详解运算符重载,赋值运算符重载,++运算符重载
【C++】详解运算符重载,赋值运算符重载,++运算符重载
|
5月前
|
编译器 C++
【C++】类和对象③(类的默认成员函数:赋值运算符重载)
在C++中,运算符重载允许为用户定义的类型扩展运算符功能,但不能创建新运算符如`operator@`。重载的运算符必须至少有一个类类型参数,且不能改变内置类型运算符的含义。`.*::sizeof?`不可重载。赋值运算符`=`通常作为成员函数重载,确保封装性,如`Date`类的`operator==`。赋值运算符应返回引用并检查自我赋值。当未显式重载时,编译器提供默认实现,但这可能不足以处理资源管理。拷贝构造和赋值运算符在对象复制中有不同用途,需根据类需求定制实现。正确实现它们对避免数据错误和内存问题至关重要。接下来将探讨更多操作符重载和默认成员函数。
|
5月前
|
C++
c++进阶篇(一)——运算符重载
c++进阶篇(一)——运算符重载