扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > 其他教程 >C++中运算符重载详解及其作用介绍
  • 717

0
分享到

C++中运算符重载详解及其作用介绍

2024-04-02 19:04:59 717人浏览 泡泡鱼
摘要

目录概述函数重载运算符重载c++ 的运算符重载运算符的规则成员函数实现 Complex 加法运算符重载的方法多种实现方法实现 operator+=三种运算符重载函数成员函数实现友元函

概述

运算符重载 (Operator Overloading)

在这里插入图片描述

函数重载

重载: 将同一名字重新赋予新的含义.
函数重载: 对一个函数赋予新的含义, 使之实现新功能. 例如:


int max(int x, int y);
double max(double a, double b, double c);

运算符也有重载: 赋予运算符新的含义, 使之一名多用. 例如


int main() {
    int i = 2, j = 3;
    int k = i + j;

    string s1 = "Good ", s2 = "morning";
    string s3 = s1 + s2;

    cout << k << endl;
    cout << s3 << endl;

    return 0;
}

输出结果:
5
good morning

运算符重载

通过运算符重载, 扩大了 C++ 已有运算符的作用, 使运算符能用于类对象. 使用运算符重载, 能使程序易于编写, 阅读和维护. 运算符被重载后, 其原有的功能仍然保留, 没有丧失过改变.

运算符重载实质上是函数的重载:

  • 定义一个重载运算符的函数
  • 需要执行被重载的运算符时, 系统就自动调用该函数, 以实现相应的运算

C++ 的运算符

  1. 算数运算符: +(加) -(减) *(乘) %(整除余数) ++(自加) – (自减)
  2. 关系运算符: >(大于) <(小于) ==(等于) >=(大于等于) <=(小于等于) !=(不等于)
  3. 逻辑运算符: &&(逻辑与) ||(逻辑或) !(逻辑非)
  4. 位运算符: <<(按位左移) >>(按位右移) &(按位与) |(按位或) ∧(按位异或) ~(按位取反)
  5. 赋值运算符: = 及其扩展赋值运算符
  6. 条件运算符: ?:
  7. 都好运算符: ,
  8. 指针运算符: *
  9. 引用运算符合地址运算符: &
  10. 求字节数运算符: sizeof
  11. 强制类型转换运算符: (类型) 或 类型()
  12. 成员运算符: .
  13. 指向成员的运算符:->
  14. 下标运算符: []
  15. 其他: 如函数调用运算符 ()

重载运算符的规则

  • 不允许创造新的运算符, 只能对已有 C++ 运算符进行重载.
  • C++ 允许重载运算符: 成员运算符(.), 成员指针访问运算符(.*), 域运算符(:😃, 求字节数运算符(sizeof), 条件运算符(?😃
  • 重载不能改变运算符运算对象 (即操作数) 的个数
  • 重载不能改变运算符的优先级别
  • 重载不能改变运算符的结合性
  • 重载运算符的函数不能有默认的参数
  • 重载的运算符必须和用户定义的自定义类型的对象一起使用. 参数至少有一个是类对象或其 引用

成员函数实现 Complex 加法

Complex 类:


#ifndef PROJECT2_COMPLEX_H
#define PROJECT2_COMPLEX_H

class Complex {
private:
    double real;
    double imag;
public:
    Complex();
    Complex(double r, double i);
    Complex add(Complex &c2);
    void display();
};

#endif //PROJECT2_COMPLEX_H

Complex.cpp:


#include <iOStream>
#include "Complex.h"
using namespace std;

Complex::Complex() : real(0), imag(0) {}

Complex::Complex(double r, double i) : real(r), imag(i) {}

Complex Complex::add(Complex &c2) {
    Complex c;
    c.real = real + c2.real;
    c.imag = imag + c2.imag;
    return c;
}

void Complex::display() {
    cout << "(" << real << ", ";
    cout << imag << "i)" << endl;
}

main:


int main() {
    Complex c1(3, 4), c2(5, -10), c3;
    cout << "c1 =";
    c1.display();
    cout << "c2 =";
    c2.display();
    c3 = c1.add(c2);
    cout << "c1 + c2 = ";
    c3.display();

    return 0;
}

输出结果:

c1 =(3, 4i)
c2 =(5, -10i)
c1 + c2 = (8, -6i)

运算符重载的方法

运算符重载格式:


函数类型 operator 运算符名称 (形参流标) {对运算符的重载处理}

Complex 类:


#ifndef PROJECT4_COMPLEX_H
#define PROJECT4_COMPLEX_H

class Complex {
private:
    double real;
    double imag;
public:
    Complex();
    Complex(double, double);
    void display();
    Complex operator+(Complex &c2);
};

#endif //PROJECT4_COMPLEX_H

Complex.cpp:


#include <iostream>
#include "Complex.h"
using namespace std;

Complex::Complex() : real(0), imag(0) {}

Complex::Complex(double r, double i) :real(r), imag(i) {}

void Complex::display() {
    cout << "(" << real << ", ";
    cout << imag << "i)" << endl;
}

Complex Complex::operator+(Complex &c2) {
    Complex c;
    c.real = real + c2.real;
    c.imag = imag + c2.imag;
    return c;
}

main:


#include <iostream>
#include "Complex.h"

using namespace std;

int main() {
    Complex c1(3, 4), c2(5, -10), c3;
    cout << "c1 =";
    c1.display();
    cout << "c2 =";
    c2.display();
    c3 = c1 + c2;
    cout << "c1 + c2 = ";
    c3.display();

    return 0;
}

输出结果:

c1 =(3, 4i)
c2 =(5, -10i)
c3= (8, -6i)

多种实现方法

成员函数实现:


Complex Complex::operator+(Complex &c2) {
    Complex c;
    c.real = real + c2.real;
    c.imag = imag + c2.imag;
    return c;
}

简化:


Complex Complex::operator+(Complex &c2){
    return Complex(real +c2.real, imag + c2.image);
}

友元函数实现:


Complex operator+(Complex &c1, Complex &c2){
    ......
}

实现 operator+=

Complex 类:


#ifndef PROJECT4_COMPLEX_H
#define PROJECT4_COMPLEX_H

class Complex {
private:
    double real;
    double imag;
public:
    Complex();
    Complex(double, double);
    void display();
    Complex operator+=(const Complex &c);
};

#endif //PROJECT4_COMPLEX_H

Complex.cpp:


#include <iostream>
#include "Complex.h"
using namespace std;

Complex::Complex() : real(0), imag(0) {}

Complex::Complex(double r, double i) :real(r), imag(i) {}

void Complex::display() {
    cout << "(" << real << ", ";
    cout << imag << "i)" << endl;
}

Complex Complex::operator+=(const Complex &c) {
    real += c.real;  // this->real += c.real;
    imag += c.imag;  // this->imag += c.imag;
    return *this;
}

main:


#include <iostream>
#include "Complex.h"

using namespace std;

int main() {
    Complex c1(3, 4), c2(5, -10), c3;
    cout << "c1 =";
    c1.display();
    cout << "c2 =";
    c2.display();
    c1 += c2;
    cout << "c1= ";
    c1.display();

    return 0;
}

输出结果:

c1 =(3, 4i)
c2 =(5, -10i)
c1= (8, -6i)

三种运算符重载函数

运算符重载函数可以是类的成员函数:

  • 它可以通过 this 指针自由地访问本类的数据成员. 少写一个函数的参数, 但有要求.

运算符重载函数可以是类的友元函数:

  • 如果运算符左侧的操作属于 C++ 标准类型 (如 int) 或是一个其他类的对象, 则运算符重载函数不能选用成员函数. 为方便访问类的私有成员, 声明为友元函数为佳.

运算符重载函数还可以是普通函数:

  • 只有极少的情况下才使用 (因普通函数一般不能直接访问类的私有成员)

成员函数实现

Complex 类:


#ifndef PROJECT4_COMPLEX_H
#define PROJECT4_COMPLEX_H

class Complex {
private:
    double real;
    double imag;
public:
    Complex();
    Complex(double, double);
    void display();
    Complex operator+(double d);  // 成员函数实现
};

#endif //PROJECT4_COMPLEX_H

Complex.cpp:


#include <iostream>
#include "Complex.h"
using namespace std;

Complex::Complex() : real(0), imag(0) {}

Complex::Complex(double r, double i) :real(r), imag(i) {}

void Complex::display() {
    cout << "(" << real << ", ";
    cout << imag << "i)" << endl;
}

Complex Complex::operator+(double d) {
    return Complex(real + d, imag);
}

友元函数实现

Complex 类:


#ifndef PROJECT4_COMPLEX_H
#define PROJECT4_COMPLEX_H

class Complex {
private:
    double real;
    double imag;
public:
    Complex();
    Complex(double, double);
    void display();
    friend Complex operator+(Complex &c, double d);  // 友元函数
};

#endif //PROJECT4_COMPLEX_H

Complex.cpp:


#include <iostream>
#include "Complex.h"
using namespace std;

Complex::Complex() : real(0), imag(0) {}

Complex::Complex(double r, double i) :real(r), imag(i) {}

void Complex::display() {
    cout << "(" << real << ", ";
    cout << imag << "i)" << endl;
}

Complex operator+(Complex &c, double d) {
    return Complex(c.real + d, c.imag);
}

输出结果

main:


#include <iostream>
#include "Complex.h"

using namespace std;

int main() {
    Complex c1(3, 4), c2(5, -10), c3, c4;
    cout << "c1 =";
    c1.display();
    cout << "c2 =";
    c2.display();

    c3 = c1 + 3.14;
    cout << "c3= ";
    c3.display();

    return 0;
}

输出结果:

c1 =(3, 4i)
c2 =(5, -10i)
c3= (6.14, 4i)

重载单元运算符

单元运算符 (unary operation), 即只有一个运算量. 如: !a, -b, &c, *p, ++i, i-- 等.

例子

重载单元运算符实现分数对象的相反数.

Fraction 类:


#ifndef PROJECT4_FRACTION_H
#define PROJECT4_FRACTION_H

#include <iostream>
using namespace std;

class Fraction {
private:
    int nume;  // 分子
    int deno;  // 分母
public:
    Fraction();
    Fraction(int, int);
    Fraction operator-(const Fraction &c);  // 分数相减
    Fraction operator-();  // 取反一目运算
    friend ostream& operator<<(ostream &output, const Fraction &f);
};

#endif //PROJECT4_FRACTION_H

Fraction.cpp:


#include "Fraction.h"

Fraction::Fraction() : nume(0), deno(0) {}

Fraction::Fraction(int n , int d) : nume(n), deno(d) {}

Fraction Fraction::operator-(const Fraction &c) {
    return Fraction(nume*c.deno - c.nume*deno, deno*c.deno);
}

Fraction Fraction::operator-() {
    return Fraction(-nume, deno);
}

ostream& operator<<(ostream &output, const Fraction &f) {
    double result = (double)f.nume / f.deno;
    output << result << endl;
    return output;
}

main:


#include <iostream>
#include "Fraction.h"
using namespace std;

int main() {
    Fraction f1(1,3), f2(1,5), f3, f4;

    f3 = f1 - f2;  // 分数相减
    f4 = -f1;  // 分数取反

    cout << f3;
    cout << f4;

    return 0;
}

输出结果:

0.133333
-0.333333

重载二元运算符

二元运算符 (binary operation).

  • 有两个操作数, 通常在运算符的左右两侧 (例如: 3+2, 5>8, x*=3)
  • 重载双目运算符时, 函数中应该有两个参数

在这里插入图片描述

例子

要求:

  • 定义字符串类 String, 用来存放不定长的字符串
  • 重载关系运算符, 用于两个字符串的比较运算

步骤:

  • 定义类的 “框架”
  • 完善运算符重载

String 类:


#ifndef PROJECT4_STRING_H
#define PROJECT4_STRING_H

#include <cstdlib>

class String {
private:
    char *p;
public:
    String(){p=nullptr;}
    String(char *str);
    void display();
};

#endif //PROJECT4_STRING_H

String.cpp:


#include <iostream>
#include <cstring>
#include "String.h"
using namespace std;

String::String(char *str) {
    p = new char[sizeof(str)];
    strcpy(p, str);
}

void String::display() {
    cout << p;
}

main:


#include <iostream>
#include "String.h"

using namespace std;

int main() {
    String s1("Hello");
    String s2("China");
    s1.display( );
    cout<<" ";
    s2.display( );
    cout<<endl;
    
    return 0;
}

输出结果:

Hello China

重载 I/O

通过重载输入流 (input stream) 和输出流 (output stream), 我们可以用来输出用户自己定义的数据.

格式:


ostream &operator<<(ostream&, const 自定义类&);
istream &operator>>(istream&,自定义类&);

在这里插入图片描述

插入运算符 <<

Complex 类:


#ifndef PROJECT4_COMPLEX_H
#define PROJECT4_COMPLEX_H

#include <iostream>
using namespace std;

class Complex {
private:
    double real;
    double imag;
public:
    Complex();
    Complex(double, double);
    void display();
    Complex operator+(Complex &c);
    friend ostream& operator<<(ostream &output, const Complex &c);
};

#endif //PROJECT4_COMPLEX_H

Complex.cpp:


#include <iostream>
#include "Complex.h"
using namespace std;

Complex::Complex() : real(0), imag(0) {}

Complex::Complex(double r, double i) :real(r), imag(i) {}

void Complex::display() {
    cout << "(" << real << ", ";
    cout << imag << "i)" << endl;
}

Complex Complex::operator+(Complex &c) {
    return Complex(real + c.real, imag + c.imag);
}

ostream &operator<<(ostream &output, const Complex &c) {
    output<<"("<<c.real<<" + "<<c.imag<<"i)";
    return output;
}

main:


#include <iostream>
#include "Complex.h"
using namespace std;

int main() {
    Complex c1(2, 4),c2(6, 10),c3;
    c3 = c1 + c2;
    cout << c1 << " + " << c2 << " = " << c3 << endl;

    return 0;
}

输出结果:

(2 + 4i) + (6 + 10i) = (8 + 14i)

提取运算符 >>

Complex 类:


#ifndef PROJECT4_COMPLEX_H
#define PROJECT4_COMPLEX_H

#include <iostream>
using namespace std;

class Complex {
private:
    double real;
    double imag;
public:
    Complex();
    Complex(double, double);
    void display();
    Complex operator+(Complex &c);
    friend ostream& operator<<(ostream &output, const Complex &c);
    friend istream& operator>>(istream &input, Complex &c);
};

#endif //PROJECT4_COMPLEX_H

Complex.cpp:


#include <iostream>
#include "Complex.h"
using namespace std;

Complex::Complex() : real(0), imag(0) {}

Complex::Complex(double r, double i) :real(r), imag(i) {}

void Complex::display() {
    cout << "(" << real << ", ";
    cout << imag << "i)" << endl;
}

Complex Complex::operator+(Complex &c) {
    return Complex(real + c.real, imag + c.imag);
}

ostream &operator<<(ostream &output, const Complex &c) {
    output<<"("<<c.real<<" + "<<c.imag<<"i)";
    return output;
}

istream &operator>>(istream &input, Complex &c) {
    cout << "input real part and imaginary part:\n";
    input >> c.real >> c.imag;
    return input;
}

main:


#include <iostream>
#include "Complex.h"
using namespace std;

int main() {
    Complex c1, c2;
    cin >> c1 >> c2;
    cout << "c1=" << c1 << endl;
    cout << "c2=" << c2 << endl;
    
    return 0;
}

输出结果:

input real part and imaginary part:
2 4
input real part and imaginary part:
6 10
c1=(2 + 4i)
c2=(6 + 10i)

总结

运算符重载使类的设计更加丰富多彩, 扩大了类的功能和使用范围. 运算符重载使得程序易于理解, 易于对对象进行操作. 有了运算符重载, 在声明了类之后, 我们就可以像使用标准类型一样来使用自己声明的类.

类的声明往往是一劳永逸的. 有了好的类, 用户在程序中就不必定义许多成员函数去完成运算和 I/O 的功能, 使主函数更加简单易读. 好的运算符重载能细心啊面向对象程序设计思想.

到此这篇关于C++中运算符重载详解及其作用介绍的文章就介绍到这了,更多相关C++运算符重载内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

--结束END--

本文标题: C++中运算符重载详解及其作用介绍

本文链接: https://lsjlt.com/news/134834.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • C++中运算符重载详解及其作用介绍
    目录概述函数重载运算符重载C++ 的运算符重载运算符的规则成员函数实现 Complex 加法运算符重载的方法多种实现方法实现 operator+=三种运算符重载函数成员函数实现友元函...
    99+
    2024-04-02
  • C++运算符重载详情介绍
    文章转自公众号：Coder梁（ID：Coder_LT） C++当中除了函数可以重载之外，其实运算符也是可以重载的。我们之前已经接触过一些，可能大家没有意识到。 举个例子，乘号*，运用...
    99+
    2024-04-02
  • C++运算符重载限制介绍
    目录一、重载限制1.必须至少有一个操作数是用户定义的类型2.不能违反运算符原来的规则3.不能创建新运算符4.禁止名单5.部分运算符只能通过成员函数重载 文章转自公众号：Co...
    99+
    2024-04-02
  • C/C++中多重继承详解及其作用介绍
    目录概述优缺点优点缺点声明多重继承的方法格式例子二义性两个基类有同名成员基类和派生类有同名成员两个基类从同一个基类派生概述 多重继承 (multiple inheritance): ...
    99+
    2024-04-02
  • C/C++中字符串流详解及其作用介绍
    目录概述字符串流理解字符串流输出字符串对象输入字符串流对象输入输出字符串流对象案例一案例二字符数组 vs 文件总结概述 文件流类和字符串流类都是 ostream, istream 和...
    99+
    2024-04-02
  • C#运算符重载的实例介绍
    本篇内容介绍了“C#运算符重载的实例介绍”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！C#运算符重载实例是掌握C#运算符重载的有效方法，那么...
    99+
    2023-06-18
  • C++中static修饰符的详解及其作用介绍
    目录概述静态数据成员引用静态数据成员用类名访问数据成员静态成员函数综合案例概述 static (静态) 修饰符是用来控制变量的存储方式和可见性的. 静态局部变量存储在静态区域: s...
    99+
    2024-04-02
  • C++中const修饰符的详解及其作用介绍
    目录概述常对象常对象成员常成员函数常数据成员数据成员访问限制常对象修改的限制常指针指向常变量的指针指向对象的指针小结对象的常引用总结概述 const 是 constant 的缩写, ...
    99+
    2024-04-02
  • C/C++中组合详解及其作用介绍
    目录概述案例总结概述 组合 (Composition) 指在一个类中另一类的对象作为数据成员. 案例 在平面上两点连成一条直线, 求直线的长度和直线中点的坐标. 要求: ...
    99+
    2024-04-02
  • C++中的运算符重载详解
    目录1、引例2、类中自动建立的函数3、重载赋值运算符解析总结1、引例 class Complex { private: double Real,Image; public: ...
    99+
    2024-04-02
  • C/C++中多态性详解及其作用介绍
    目录概述静态多态函数重载运算符重载动态多态非动态动态概述 多态性 (polymorphism) 是面向对象程序设计的一个重要特征. 利用多态性扩展设计和实现一个易于扩展的系统. C...
    99+
    2024-04-02
  • C/C++中虚基类详解及其作用介绍
    目录概述多重继承的问题虚基类初始化例子总结概述 虚基类 (virtual base class) 是用关键字 virtual 声明继承的父类. 多重继承的问题 N 类: cla...
    99+
    2024-04-02
  • C/C++中虚函数详解及其作用介绍
    目录概述使用方法关联静态关联动态关联案例1未使用虚函数使用虚拟类案例2总结概述 虚函数 (virtual function) 指可以被子类继承和覆盖的函数. 使用方法 基类声明成员...
    99+
    2024-04-02
  • C/C++中抽象类详解及其作用介绍
    目录概述抽象类 vs 具体类案例抽象类的作用总结概述 抽象类 (abstract class), 是一些不用来定义对象, 而只作为基类被继承的类. 由于抽象类常用作基类, 所以通常称...
    99+
    2024-04-02
  • C++中继承(inheritance)详解及其作用介绍
    概述 面向对象程序设计中最重要的一个概念是继承 (inheritance). 继承允许我们依据另一个类来定义一个类, 这使得创建和维护一个应用程序变得更统一. 这样做也达到了重用代码...
    99+
    2024-04-02
  • C++中模板(Template)详解及其作用介绍
    目录概述函数模板类模板模板类外定义成员函数类库模板抽象和实例概述 模板可以帮助我们提高代码的可用性, 可以帮助我们减少开发的代码量和工作量. 函数模板 函数模板 (Function...
    99+
    2024-04-02
  • C++中友元的详解及其作用介绍
    目录概述友元普通的友元函数友元成员函数友元类总结概述 类的友元函数 (friend) 是定义在类外部, 但是有权限访问类的所有私有 (private) 成员和保护 (protecte...
    99+
    2024-04-02
  • C++中指针的详解及其作用介绍
    目录概述指向对象的指针指向对象数据成员的指针this 指针this 指针的作用this 指针的实现概述 指针 (pointer) 是一个变量, 其指为另一个变量的地址. 即内存位置的...
    99+
    2024-04-02
  • C++中运算符重载问题详解
    C++中运算符重载问题详解运算符重载是C++中的一个重要特性，它允许我们为自定义的类类型重载运算符，使得这些类对象之间的运算能够像内置类型一样进行。在本文中，我们将详细讨论C++中运算符重载的概念、使用方法以及常见的问题。一、什么是运算符重...
    99+
    2023-10-22
    问题详解 C++运算符重载
  • C/C++中I/O进阶详解及其作用介绍
    目录概述I/O 类库I/O 中的重载流对象标准输入流cin 流对象案例get 函数getline 函数eof 函数cout 流对象cerr 流对象clog 流对象概述 C++ 的输入...
    99+
    2024-04-02
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作