重载图节点+运算符报错：Node*类型无法执行二元+操作

编译报错信息：

error: invalid operands of types ‘Node*’ and ‘Node*’ to binary ‘operator+’
   30 |     c = a + b;
      |         ~ ^ ~
      |         |   |
      |         |   Node*
      |         Node*

我通过add()成员方法可以正常完成两个Node节点的加法，但用相同思路实现operator+()时却编译失败，这是为什么？

我的代码如下：

#include <iostream>

class Node {
    public:
        double data;
        Node () {}
        Node (double x) : data(x) {}
        Node* add(Node *rhs);
};

// 可以正常工作
Node* Node::add(Node *rhs) {
    Node* value = new Node();
    value->data = this->data + rhs->data;
    return value;
}

// 无法编译通过
// Node* operator+ (Node* lhs, Node* rhs) {
//     Node* value = new Node();
//     value->data = lhs->data + rhs->data;
//     return value;
// }

int main(void) {

    Node* a = new Node(2.0);
    Node* b = new Node(3.0);

    Node* c = nullptr;
    c = a->add(b); // 正常工作
    // c = a + b;  // 编译失败
    std::cout << c->data << "\n";

    delete a;
    delete b;
    delete c;

    return 0;
}

编译命令：

g++ -std=c++20 -O -Wall -Wextra -Wpedantic graph.cc

核心原因 #

C标准不允许为内置类型（包括指针类型）重载运算符。你尝试重载的是两个Node*指针的operator+，而指针属于C内置类型范畴，编译器会直接拒绝这种重载请求，这就是报错的根本原因。

而add()方法能正常工作，是因为a->add(b)是通过指针调用对象的成员函数，实际操作的是指针指向的Node对象本身，而非指针类型。

解决方法 #

方法1：重载对象版的operator+（推荐）

不要针对指针重载，改为针对Node对象重载operator+，使用时对指针解引用操作对象：

#include <iostream>

class Node {
    public:
        double data;
        Node () {}
        Node (double x) : data(x) {}
        Node* add(Node *rhs);
        // 声明成员版operator+，操作对象而非指针
        Node operator+(const Node& rhs) const;
};

Node* Node::add(Node *rhs) {
    Node* value = new Node();
    value->data = this->data + rhs->data;
    return value;
}

// 实现operator+
Node Node::operator+(const Node& rhs) const {
    return Node(this->data + rhs.data);
}

int main(void) {
    Node* a = new Node(2.0);
    Node* b = new Node(3.0);

    Node* c = nullptr;
    c = a->add(b);
    // 对指针解引用，操作对象
    Node d = *a + *b;
    std::cout << c->data << "\n";
    std::cout << d.data << "\n";

    delete a;
    delete b;
    delete c;

    return 0;
}

如果需要返回指针，可以调整operator+的返回值，但更推荐直接返回对象，避免不必要的堆内存分配。

方法2：避免重载指针运算符，使用普通函数

如果一定要基于指针操作，不要重载operator+，而是定义一个普通的全局函数：

Node* add_nodes(Node* lhs, Node* rhs) {
    Node* value = new Node();
    value->data = lhs->data + rhs->data;
    return value;
}

调用时用c = add_nodes(a, b);即可。

额外建议 #

尽量避免用裸指针管理内存，推荐使用std::unique_ptr或std::shared_ptr智能指针，自动管理内存，减少内存泄漏风险。

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