【C++】 运算符重载

最新推荐文章于 2021-10-29 17:23:49 发布
最新推荐文章于 2021-10-29 17:23:49 发布
阅读量579 收藏 1
点赞数 1
分类专栏： 编程语言 文章标签： c++ operator 运算符 重载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ieearth/article/details/78750706
版权

1、一元运算符

运算符重载是C++的一大特色，以函数重载的形式出现，函数名为关键字operator后跟着一个运算符，这些函数可以作为类的成员函数实现，也可以作为类的友元函数以全局函数的形式实现，而有的操作符只能以其中一种方式实现，因为全局函数没有this指针，所以在参数列表中比成员函数多一个参数。可以重载的一元运算符包括+、-、~、&、!、++、--，例子如下。

// Overloading Unary Operators
// Non-member functions
class Integer {
    long i;
    Integer* This() { return this; }
public:
    Integer(long ll = 0) : i(ll) {}
    // No side effects takes const& arguments
    friend const Integer& operator+(const Integer& a);
    friend const Integer operator-(const Integer& a);
    friend const Integer operator~(const Integer& a);
    friend Integer* operator&(Integer& a);
    friend int operator!(const Integer& a);
    // Side effects have non-const& argument
    // Prefix
    friend const Integer& operator++(Integer& a);
    // Postfix
    friend const Integer operator++(Integer& a, int);
    // Prefix
    friend const Integer& operator--(Integer& a);
    // Postfix
    friend const Integer operator--(Integer& a, int);
};
// Global operators
const Integer& operator+(const Integer& a) {
    return a; // Unary + has no effect
}
const Integer operator-(const Integer& a) {
    return Integer(-a.i);
}
const Integer operator~(const Integer& a) {
    return Integer(~a.i);
}
Integer* operator&(Integer& a) {
    return a.This(); // &a is recursive!
}
int operator!(const Integer& a) {
    return !a.i;
}
// Prefix; return incremented value
const Integer& operator++(Integer& a) {
    a.i++;
    return a;
}
// Postfix; return the value before increment:
const Integer operator++(Integer& a, int) {
    Integer before(a.i);
    a.i++;
    return before;
}
// Prefix; return decremented value
const Integer& operator--(Integer& a) {
    a.i--;
    return a;
}
// Postfix; return the value before decrement:
const Integer operator--(Integer& a, int) {
    Integer before(a.i);
    a.i--;
    return before;
}
// Member functions (implicit "this")
class Byte {
    unsigned char b;
public:
    Byte(unsigned char bb = 0) : b(bb) {}
    // No side effects: const member function
    const Byte& operator+() const {
        return *this;
    }
    const Byte operator-() const {
        return Byte(-b);
    }
    const Byte operator~() const {
        return Byte(~b);
    }
   Byte operator!() const {
        return Byte(!b);
    }
    Byte* operator&() {
        return this;
    }
    // Side effects: non-const member function
    const Byte& operator++() { // Prefix
        b++;
        return *this;
    }
    const Byte operator++(int) { // Postfix
        Byte before(b);
        b++;
        return before;
    }
    const Byte& operator--() { // Prefix
        b--;
        return *this;
    }
    const Byte operator--(int) { // Postfix
        Byte before(b);
        b--;
        return before;
    }
};

2、二元运算符

可以重载的二元运算符包括+、-、*、/、%、^、&、|、<<、>>、+=、-=、*=、/=、%=、^=、&=、|=、<<=、>>=，例子如下。二元运算符一般使用非成员函数。

// Overloading Binary Operators
// Non-member overloaded operators
// Non-member functions
class Integer {
    long i;
public:
    Integer(long ll = 0) : i(ll) {}
    // Operators that create new, modified value
    friend const Integer operator+(const Integer& left, const Integer& right);
    friend const Integer operator-(const Integer& left, const Integer& right);
    friend const Integer operator*(const Integer& left, const Integer& right);
    friend const Integer operator/(const Integer& left, const Integer& right);
    friend const Integer operator%(const Integer& left, const Integer& right);
    friend const Integer operator^(const Integer& left, const Integer& right);
    friend const Integer operator&(const Integer& left, const Integer& right);
    friend const Integer operator|(const Integer& left, const Integer& right);
    friend const Integer operator<<(const Integer& left, const Integer& right);
    friend const Integer operator>>(const Integer& left, const Integer& right);
    // Assignments modify & return lvalue
    friend Integer& operator+=(Integer& left, const Integer& right);
    friend Integer& operator-=(Integer& left, const Integer& right);
    friend Integer& operator*=(Integer& left, const Integer& right);
    friend Integer& operator/=(Integer& left, const Integer& right);
    friend Integer& operator%=(Integer& left, const Integer& right);
    friend Integer& operator^=(Integer& left, const Integer& right);
    friend Integer& operator&=(Integer& left, const Integer& right);
    friend Integer& operator|=(Integer& left, const Integer& right);
    friend Integer& operator<<=(Integer& left, const Integer& right);
    friend Integer& operator>>=(Integer& left, const Integer& right);
    // Conditional operators return true/false
    friend int operator==(const Integer& left, const Integer& right);
    friend int operator!=(const Integer& left, const Integer& right);
    friend int operator<(const Integer& left, const Integer& right);
    friend int operator>(const Integer& left, const Integer& right);
    friend int operator<=(const Integer& left, const Integer& right);
    friend int operator>=(const Integer& left, const Integer& right);
    friend int operator&&(const Integer& left, const Integer& right);
    friend int operator||(const Integer& left, const Integer& right);
};
// Implementation of overloaded operators
const Integer operator+(const Integer& left, const Integer& right) {
    // Integer tmp(left.i + right.i); // 调用构造函数创建tmp对象
    // return tmp; // 调用拷贝构造函数把tmp拷贝到外部返回值的存储单元 调用析构函数销毁tmp对象
    return Integer(left.i + right.i); // 返回值优化 返回临时对象告诉编译器直接把这个对象创建在外部返回值的存储单元里
}
const Integer operator-(const Integer& left, const Integer& right) {
    return Integer(left.i - right.i);
}
const Integer operator*(const Integer& left, const Integer& right) {
    return Integer(left.i * right.i);
}
const Integer operator/(const Integer& left, const Integer& right) {
    return Integer(left.i / right.i); // right.i != 0
}
const Integer operator%(const Integer& left, const Integer& right) {
    return Integer(left.i % right.i); // right.i != 0
}
const Integer operator^(const Integer& left, const Integer& right) {
    return Integer(left.i ^ right.i);
}
const Integer operator&(const Integer& left, const Integer& right) {
    return Integer(left.i & right.i);
}
const Integer operator|(const Integer& left, const Integer& right) {
    return Integer(left.i | right.i);
}
const Integer operator<<(const Integer& left, const Integer& right) {
    return Integer(left.i << right.i);
}
const Integer operator>>(const Integer& left, const Integer& right) {
    return Integer(left.i >> right.i);
}
// Assignments modify & return lvalue
Integer& operator+=(Integer& left, const Integer& right) {
    if(&left == &right) {/* self-assignment*/}
    left.i += right.i;
    return left;
}
Integer& operator-=(Integer& left, const Integer& right) {
    if(&left == &right) {/* self-assignment*/}
    left.i -= right.i;
    return left;
}
Integer& operator*=(Integer& left, const Integer& right) {
    if(&left == &right) {/* self-assignment*/}
    left.i *= right.i;
    return left;
}
Integer& operator/=(Integer& left, const Integer& right) {
    // right.i != 0
    if(&left == &right) {/* self-assignment*/}
    left.i /= right.i;
    return left;
}
Integer& operator%=(Integer& left, const Integer& right) {
    // right.i != 0
    if(&left == &right) {/* self-assignment*/}
    left.i %= right.i;
    return left;
}
Integer& operator^=(Integer& left, const Integer& right) {
    if(&left == &right) {/* self-assignment*/}
    left.i ^= right.i;
    return left;
}
Integer& operator&=(Integer& left, const Integer& right) {
    if(&left == &right) {/* self-assignment*/}
    left.i &= right.i;
    return left;
}
Integer& operator|=(Integer& left, const Integer& right) {
    if(&left == &right) {/* self-assignment*/}
    left.i |= right.i;
    return left;
}
Integer& operator<<=(Integer& left, const Integer& right) {
    if(&left == &right) {/* self-assignment*/}
    left.i <<= right.i;
    return left;
}
Integer& operator>>=(Integer& left, const Integer& right) {
    if(&left == &right) {/* self-assignment*/}
    left.i >>= right.i;
    return left;
}
// Conditional operators return true/false
int operator==(const Integer& left, const Integer& right) {
    return left.i == right.i;
}
int operator!=(const Integer& left, const Integer& right) {
    return left.i != right.i;
}
int operator<(const Integer& left, const Integer& right) {
    return left.i < right.i;
}
int operator>(const Integer& left, const Integer& right) {
    return left.i > right.i;
}
int operator<=(const Integer& left, const Integer& right) {
    return left.i <= right.i;
}
int operator>=(const Integer& left, const Integer& right) {
    return left.i >= right.i;
}
int operator&&(const Integer& left, const Integer& right) {
    return left.i && right.i;
}
int operator||(const Integer& left, const Integer& right) {
    return left.i || right.i;
}
// Member overloaded operators
// Member functions (implicit "this")
class Byte {
    unsigned char b;
public:
    Byte(unsigned char bb = 0) : b(bb) {}
    const Byte operator+(const Byte& right) const {
        return Byte(b + right.b);
    }
    const Byte operator-(const Byte& right) const {
        return Byte(b - right.b);
    }
    const Byte operator*(const Byte& right) const {
        return Byte(b * right.b);
    }
    const Byte operator/(const Byte& right) const {
        return Byte(b / right.b); // right.b != 0
    }
    const Byte operator%(const Byte& right) const {
        return Byte(b % right.b); // right.b != 0
    }
    const Byte operator^(const Byte& right) const {
        return Byte(b ^ right.b);
    }
    const Byte operator&(const Byte& right) const {
        return Byte(b & right.b);
    }
    const Byte operator|(const Byte& right) const {
        return Byte(b | right.b);
    }
    const Byte operator<<(const Byte& right) const {
        return Byte(b << right.b);
    }
    const Byte operator>>(const Byte& right) const {
        return Byte(b >> right.b);
    }
    // Assignments modify & return lvalue.
    // operator= can only be a member function
    Byte& operator=(const Byte& right) {
        // Handle self-assignment
        if(this == &right) return *this;
        b = right.b;
        return *this;
    }
    Byte& operator+=(const Byte& right) {
        if(this == &right) {/* self-assignment */}
        b += right.b;
        return *this;
    }
    Byte& operator-=(const Byte& right) {
        if(this == &right) {/* self-assignment */}
        b -= right.b;
        return *this;
    }
    Byte& operator*=(const Byte& right) {
        if(this == &right) {/* self-assignment */}
        b *= right.b;
        return *this;
    }
    Byte& operator/=(const Byte& right) {
        if(this == &right) {/* self-assignment */}
        b /= right.b; // right.b != 0
        return *this;
    }
    Byte& operator%=(const Byte& right) {
        if(this == &right) {/* self-assignment */}
        b %= right.b; // right.b != 0
        return *this;
    }
    Byte& operator^=(const Byte& right) {
        if(this == &right) {/* self-assignment */}
        b ^= right.b;
        return *this;
    }
    Byte& operator&=(const Byte& right) {
        if(this == &right) {/* self-assignment */}
        b &= right.b;
        return *this;
    }
    Byte& operator|=(const Byte& right) {
        if(this == &right) {/* self-assignment */}
        b |= right.b;
        return *this;
    }
    Byte& operator<<=(const Byte& right) {
        if(this == &right) {/* self-assignment */}
        b <<= right.b;
        return *this;
    }
    Byte& operator>>=(const Byte& right) {
        if(this == &right) {/* self-assignment */}
        b >>= right.b;
        return *this;
    }
    // Conditional operators return true/false:
    int operator==(const Byte& right) const {
        return b == right.b;
    }
    int operator!=(const Byte& right) const {
        return b != right.b;
    }
    int operator<(const Byte& right) const {
        return b < right.b;
    }
    int operator>(const Byte& right) const {
        return b > right.b;
    }
    int operator<=(const Byte& right) const {
        return b <= right.b;
    }
    int operator>=(const Byte& right) const {
        return b >= right.b;
    }
    int operator&&(const Byte& right) const {
        return b && right.b;
    }
    int operator||(const Byte& right) const {
        return b || right.b;
    }
};

3、下标运算符

下标运算符[]，行为像数组一样，必须是成员函数，只接受一个参数。

class ByteArray
{
public:
    char operator[](int i) const;
};

4、new和delete

运算符new和delete也可以进行重载，全局函数或者成员函数，用于控制动态存储分配，不过一般不这么做。

void* operator new(std::size_t)
void* operator new[](std::size_t);
void operator delete(void*);
void operator delete[](void*);
inline void* operator new(std::size_t, void *p) { return p; }
inline void* operator new[](std::size_t, void *p) { return p; }
inline void operator delete(void*, void*) {}
inline void operator delete[](void*, void*) {}

5、逗号

当逗号出现在一个对象左右，而该对象的类型是逗号定义所支持的类型时，将调用逗号运算符，然后，调用的目标不是函数参数表，而是被逗号分隔开的、没有被括号括起来的对象，除了使语言保持一致性外，这个运算符似乎没有许多实际用途。

class After
{
pubic:
    const After& operator,(const After&) const { return *this; }
};
class Before {};
Before& operator,(int, Before &b) { return b; }
void test()
{
    After a, b;
    a, b; // operator, called
    Before c;
    1, c; // operator, called
}

6、指针

下面是几个特殊的可重载运算符。当希望一个对象表现的像一个指针时，通常就要用到指针间接引用运算符operator->，它是个成员函数，由于这样一个对象比一般的指针有着更多与生俱来的灵巧性，于是常被称作为灵巧指针。

class Object {};
class ObjectContainer
{
public:
    vector<Object*> objs;
};
class SmatrPointer
{
pubic:
    Object* operator->() const { return oc.objs[index]; }
private:
    ObjectContainer &oc;
    int index;
};

另外，运算符operator->*用于成员指针；operator()是个多功能函数，参数不受限制，可以实现任意特定的功能；括号运算符进行类型转换时格式为operator Type()，它们都是成员函数。在类型转换中，有时会通过构造函数自动进行类型转换，这可能会有问题，解决方法是在构造函数前面使用explicit关键字。

class Dog()
{
public:
    int run(int i) const { return i; }
    typedef int (Dog::*PMF)(int) const;
    class FuncObj
    {
    public:
        FuncObj(Dog *dog, PMF pmf) : ptr(dog), pmem(pmf) {}
        int operator()(int i) const { return (ptr->*pmem)(i); }
    private:
        Dog *ptr;
        PMF pmem;
    };
    FuncObj operator->*(PMF pmf)
    {
        return FuncObj(this, pmf);
    } 
}
void test()
{
    Dog d;
    Dog::PMF pmf = &Dog::run;
    (d->*pmf)(1);
}

Class A()
{
public:
    A(B* bb) : b(bb) {}
private:
    B* b;
};
Class B()
{
public:
    operator A() const { return A(this); } // B转换为A
};

7、输入输出

输入输出运算符operator>>、operator<<作为全局函数，可以自定义任何想要的结果。

class Integer
{
    friend ostream& operator<<(ostream& os, const Integer &r);
    friend istream& operator>>(istream& is, Inteter &r);
    int num;
};
ostream& operator<<(ostream& os, const Integer &r)
{
    os << r.num;
    os << endl;
    return os;
}
istream& operator>>(istream& is, Inteter &r)
{
    is >> r.num;
    return is;
}

8、不能重载的运算符

在可用的运算符集合里，存在一些不能重载的运算符，如下。

operator.
operator.*
user custom operator
会飞的代码UP
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++运算符重载规则详解
09-03
主要介绍了C++运算符重载规则详解,是C++入门学习中的基础知识,需要的朋友可以参考下
C++回顾——运算符重载
チンポー的博客
08-20 199
运算符重载只是一种语法上的方便，实际上它是另一种函数调用的方式，其不同之处在于函数的参数不是出现在圆括号内，而是紧贴在一些字符旁边；调用运算符时要把运算符放置在参数之间、参数之后、参数之前；编译器决定调用哪一个“函数”。 在C++中，可以定义一个处理类的新运算符，函数的名字由关键字operator及其后紧跟的运算符组成。 一、语法 函数名字是operator@，这里@代表了被重载的运算符。参...
《C++编程思想》 第十一章 运算符重载 （原书代码+习题+解答）
罗小黑の窝
08-08 1053
一.相关代码 1. /*运算符重载语法*/ /*OPOVER.cpp*/ /*这两个重载的运算符被定义为内联成员函数。对于二元运算符，单个参数是出现在运算符 右侧的那个。当一元运算符被定义为成员函数时，没有参数。成员函数被运算符左侧的对象调 用。 对于非条件运算符（条件运算符通常返回一个布尔值），如果两个参数是相同的类型，希 望返回和运算相同类型的对象或引用。如果它们不是相同类型，它作什么样的
运算符重载
helpbs
07-22 95
class byte { unsigned char b; public: byte(unsigned char B = 0 ):b(B){} //@一元运算符 //no side effects: const member function: const byte&amp; operator+() const{ return *this; } const byte opera...
Think_in_CPP第十二章 操作符重载(2)
tjcbq的专栏
09-15 326
12.3 二元运算符(Binary operators) 12.3.1 全局函数方式 class Integer { long i; public: Integer(long ll = 0) : i(ll) {} // Operators that create new, modified value: friend const Integer operator
C++运算符重载课件
09-17
中国农业大学C++课程课件，信息与电气工程学院学生专用。
C++运算符重载
05-18
C++运算符重载:赋予运算符另一种作用，实现自定义类型的运算C++运算符重载内容： 1.友元重载 2.类重载 3.输入输出流重载
c++运算符重载
03-12
最全的c++运算符重载，包括赋值、比较、自增自减，包括成员函数和友员函数方式。
从零开始学C++之运算符重载（四）：类型转换运算符、*运算符重载、->运算符重载、operator new 和 operator delete
Meditation
07-10 4451
一、类型转换运算符 必须是成员函数，不能是友元函数 没有参数 不能指定返回类型 函数原型：operator 类型名();  C++ Code  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #ifndef
const 和non-const成员函数转化
TYtrack的博客
10-29 1009
翻译：GAN下的深度学习模型：协作深度学习中的信息泄漏 链接：https://arxiv.org/abs/1702.07464. ABSTRACT 深度学习最近因其能够解决端到端学习系统而在机器学习中 非常流行，在该系统中，特征和分类器同时学习，在高结构 化和大型数据库的存在下显著提高了分类精度。 它的成功是由于最近的算法突破、越来越强大的计算机和 对大量数据的访问。 研究人员还考虑了深度学习的隐私影响。模型通常以集中 的方式训练，所有的数据都由相同的训练算法处理。如果这 些数.
【C++】成员函数重载二元和一元运算符
weixin_33937499的博客
09-22 408
重载双目运算符时，运算符函数中应该具有两个参数，若运算符函数作为类的成员函数(当运算符重载函数作为类的成员函数时，要求操作数左边必须是一个对象，而函数的参数可以是同类的对象也可以是普通的变量)，则只需要一个参数。 双目运算符 双目运算符就是具有两个操作数的运算符。如 +、-、==等。 对双目运算符而言，成员函数重载...
《C++primer》第4版 和《C++编程思想》 读书笔记
记录学习过程
06-03 2129
/******************************** C++笔记 自己记录的觉得关键 容易忘得东西 内容杂乱没有次序不适合学习 参考内容来自《C++primer》第4版 《C++编程思想》第二版 第一卷第二卷 仅供参考 ！！！！！！！！！！有错误的地方见谅可能抄错了！！！！！！！！！！！！！ QQ710055071 十二年/DZF ********************
Think_in_CPP第十二章 操作符重载(3)
tjcbq的专栏
09-15 271
12.4 操作符重载中的参数和返回值 12.4.1 单目运算符 全局函数方式 const Integer& operator+(const Integer& a); const Integer operator-(const Integer& a); const Integer operator~(const Integer& a); Integer* operat
c++中临时变量不能作为非const的引用参数
热门推荐
一碗米线
02-05 1万+
引自：http://blog.baisi.net/?116670/viewspace-4407 试看下面的代码： #include using namespace std; void f(int &a)  {  cout } void g(const int &a) {  cout }  int main()  {  int a = 3, b = 4;
C++编程思想 第1卷 第12章 运算符重载 可重载的运算符 二元运算符 自增和自减
eyetired的博客
07-27 153
二元运算符所有可重载运算符，全局版本和成员函数版本   //: C12:Integer.h // From Thinking in C++, 2nd Edition // Available at http://www.BruceEckel.com // (c) Bruce Eckel 2000 // Copyright notice in Copyright.txt // Non-memb...
C++运算符重载学习的好例子（thinking in c++）
ma328762444的专栏
09-04 420
//:UNARY.CPP -- Overloading unary operators#include using namespace std;class integer { long i; integer*  This() { return this; }public: integer (long I = 0):i(I) {} //No side effects takes const& arg

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值