C++能否自定义非标准特殊运算符实现Marks类对象运算

核心结论 #

C标准不支持定义完全自定义的全新运算符标识符，你不能直接创建specialoperator、-MYoperator-这类不在C预定义运算符列表中的独立运算符。C++运算符重载的规则是只能对语言原生提供的运算符（如+、-、*、/、()等）进行重载，不支持新增运算符类型。

替代实现方案 #

如果要实现类似自定义运算符的调用效果，有两种常用的实现方式：

方案1：使用普通成员函数（最推荐） #

直接给Marks类实现对应逻辑的成员函数，函数名可以自定义，调用逻辑清晰无额外成本，示例代码如下：

#include <iostream>
using namespace std;

class Marks {
    int intmark;
    int extmark;
public:
    Marks() : intmark(0), extmark(0) {}
    Marks(int im, int em) : intmark(im), extmark(em) {}
    void display() {
        cout << intmark << endl << extmark << endl;
    }

    // 自定义函数名实现对应运算逻辑
    Marks specialoperator(const Marks& other) const {
        Marks temp;
        temp.intmark = intmark + other.intmark;
        temp.extmark = extmark + other.extmark;
        return temp;
    }
};

int main()
{
    Marks m1(10, 20), m2(30, 40);
    Marks m3;
    // 调用自定义函数完成运算
    m3 = m1.specialoperator(m2);
    m3.display();
    return 0;
}

方案2：利用现有运算符包裹自定义标识（语法糖效果） #

如果一定要实现m3 = m1 -MYoperator- m2这类中缀形式的调用，可以通过重载现有运算符+中间辅助对象的方式实现，本质是用原生运算符包裹你自定义的标识，达到类似自定义运算符的视觉效果，示例代码如下：

#include <iostream>
using namespace std;

// 自定义标识的空类型，创建全局标识对象
struct MYoperator_t {} MYoperator;
// 中间辅助类，用于存储左操作数
class MarksOpProxy {
    const Marks& left;
public:
    MarksOpProxy(const Marks& l) : left(l) {}
    // 重载右-运算符，和右操作数运算返回结果
    Marks operator-(const Marks& right) const;
};

class Marks {
    int intmark;
    int extmark;
public:
    Marks() : intmark(0), extmark(0) {}
    Marks(int im, int em) : intmark(im), extmark(em) {}
    void display() {
        cout << intmark << endl << extmark << endl;
    }
    // 声明友元允许访问私有成员
    friend Marks MarksOpProxy::operator-(const Marks& right) const;
    // 重载左-运算符，接收自定义标识返回中间代理对象
    MarksOpProxy operator-(const MYoperator_t& op) const {
        return MarksOpProxy(*this);
    }
};

// 实现代理类的运算逻辑
Marks MarksOpProxy::operator-(const Marks& right) const {
    Marks temp;
    temp.intmark = left.intmark + right.intmark;
    temp.extmark = left.extmark + right.extmark;
    return temp;
}

int main()
{
    Marks m1(10, 20), m2(30, 40);
    Marks m3;
    // 按自定义格式调用，视觉上类似自定义运算符
    m3 = m1 -MYoperator- m2;
    m3.display();
    return 0;
}

注意：该方案属于语法糖，本质还是对原生-运算符的重载，会增加额外的抽象成本，非特殊场景不推荐使用。

内容的提问来源于stack exchange，提问作者8888