重载运算符编译错误？

Question

所以我试图重载 ^ 运算符以执行我的两个集合之间的交集，但我一直收到此编译时错误“二进制表达式的操作数无效。

交集=列表^ listTwo；是导致错误的原因

我的方法无需重载即可正常工作。

这是我的头文件。

#ifndef SetHeader_h
#define SetHeader_h

template<typename T>
class Node{

     public:
     T data;
     Node<T> *next;

};

template<typename T>
class SetADT{

private:
     Node<T> *head;

public:
     SetADT();
     ~SetADT();
     void add(T data);
     void print();
     bool isDuplicate(T data) const;
     SetADT<T> operator ^ (SetADT<T> node);

};


#endif /* SetHeader_h */

这是我的 cpp 文件

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

template <typename T>
SetADT<T> ::SetADT(){
    head = NULL;
}
template<typename T>
SetADT<T> :: ~SetADT<T>(){

    cout<<"Set deleted!" << endl;
}

 template<typename T>
 bool SetADT<T>::isDuplicate(T data) const{

    Node<T> *cur = this->head;

      while (cur) {
         if (cur->data == data) {
           return true;
      }
        cur=cur->next;
     }
   return false;
 }


    template <typename T>
    void SetADT<T>:: add(T data){

    Node<T> *node = new Node<T>();

    bool isPresent = isDuplicate(data);

    if (!isPresent) {
        node->data = data;
        node->next = this->head;
        this->head = node;
    }
}

template <typename T>
void SetADT<T>:: print(){

    Node<T> *head = this->head;

    if (head == NULL) {
        cout << "{}";
    }

    Node<T> *cur = head;

    while (cur) {
        cout << cur->data << ' ';
        cur = cur->next;
    }
    cout << endl;
}


template <typename T>
SetADT<T> SetADT<T> :: operator &(SetADT<T> one){
    SetADT<T> result;

    Node<T> *setACurrent = this->head;

    while (setACurrent) {
        if (one.isDuplicate(setACurrent->data)) {
            result.add(setACurrent->data);
        }

        setACurrent = setACurrent->next;

    }
    return result;
}


int main (){


    SetADT<int> list;
    list.add(10);
    list.print();

    SetADT<int> listTwo;
    listTwo.add(10);
    list.print();

    SetADT<int> intersection;

     //error right here
    intersection = list ^ listTwo;


    return 0;

}

Answer 1

list ^ listTwo;

list和listTwo都是一个SetADT<int> *，指向这个模板实例的指针。这个 ^ 运算符的两个操作数都是 pointers.

template<typename T>
class SetADT{

// ...
     SetADT<T>* operator ^ (SetADT<T> *node);

这里你定义了一个SetADT<T>的^运算符，而not一个SetADT<T> *.

此 operator^ 声明最终会在 class 的实例上重载运算符 ，而不会在指向 class.

实例的指针上
这就是 operator 成员的工作方式：它们在 class 的实例上重载运算符，而不是在指向 class.[=26= 的实例的指针上]
如果您想正确调用此运算符，正确的语法是：

(*list) ^ listTwo

在这里，*list 取消引用指向 class 的实例的指针，因此您最终得到（对）class 的实例，它有一个 operator^ 重载，将指向相同 class 的实例的指针作为参数。

请注意，您的 operator 重载参数是一个指向 class 实例的指针，并且由于 listTwo 是这样一个指针，所以这应该有效。

您犯的一般错误是您没有正确理解 class 和指向 class 实例的指针之间的根本区别。这不是一件小事，而是一个重要的区别。如果某物被定义为适用于 class 的实例，它期望有一个 class 的实例可以使用，而不是此类 class 的指针。反之亦然。

Answer 2

你的问题的本质是运算符函数是为 class SetADT<T> 定义的，但是你正试图对指针（指向对象）调用 ^ 运算符；编译器与您的运算符函数实现不匹配您的使用。仅定义了按位异或 (^) 运算符，它不知道如何处理 SetADT<T> 个参数。

为了让编译器将调用与您的声明相匹配，您需要取消引用左侧 "argument," list。

intersection = *list ^ listTwo;

我可能建议您编写运算符以接受引用参数而不是指针，如下所示：

SetADT<T>* operator ^ (SetADT<T> &node) { … }

然后调用它，

intersection = *list ^ *listTwo;

当然，如果有理由，您可以保留现有的 declaration/definition，但这并不 nice。您应该考虑返回对对象的引用而不是指针。而且，为了完整起见，您还应该考虑实施 ^= 运算符。

SetADT<T>& operator ^ (SetADT<T> &node);
SetADT<T>& operator ^=(const X& rhs);

然后用于 ^ 运算符的表达式可能如下所示，

*intersection = *list ^ *listTwo;

重载运算符编译错误？

Overloading operator compile error?

c++

operator-overloading

operator-keyword