Question

所以我试图重载^运算符来执行我的两个集合之间的交集，但是我一直得到这个编译时错误＆＃34;二进制表达式的操作数无效。

intersection = list ^ 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> *，指向此模板实例的指针。这个^运算符的两个操作数都是指针。

template<typename T>
class SetADT{

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

您在此处定义了^的{{1}}运算符，不 SetADT<T>。

此SetADT<T> *声明最终会在类的实例上重载运算符，而不会在指向班级的实例。

这就是operator^成员的工作方式：它们在类的实例上重载操作符，而不是指向类实例的指针。

如果您想正确调用此运算符，则正确的语法为：

operator

这里，(*list) ^ listTwo取消引用指向类实例的指针，因此最终得到（引用）类的实例，该实例具有*list重载，该指针指向与参数相同的类的实例。

请注意，您的operator^重载参数是指向该类实例的指针，并且由于operator是指针，因此这应该有效。

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

Answer 2

你的问题的本质是为类SetADT<T>定义了运算符函数，但是你正试图针对指针（对象）调用^运算符;编译器与您的运算符函数实现不符合您的用法。只定义了bitwise-xor（^）运算符，它不知道如何处理SetADT<T>个参数。

为了让编译器将调用与您的声明匹配，您需要取消引用左侧“参数”list。

intersection = *list ^ listTwo;

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

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

然后你调用它，

intersection = *list ^ *listTwo;

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

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

然后用于^运算符的表达式可能看起来像

*intersection = *list ^ *listTwo;

重载运算符编译错误？

2 个答案: