Question

我相信我的运算符重载不适用于我的两种数据类型之一。我的程序使用int数据类型，但不适用于我定义的类学生。学生是指针树，所以这可能是我的问题。当我的搜索功能没有按计划运行时，我发现了这个问题。我希望得到一些关于我的重载运算符出错的建议。

struct Students{

char lastName[20];
char firstName[20];
int IDnumber;
Students();
bool operator == (const Students);
bool operator > (const Students);
bool operator < (const Students);

friend ostream& operator << (ostream& stream, const Students* students);

};

template <class DataType>
TNode<DataType>* BST<DataType>::bstSearch(DataType search)
{
 TNode<DataType>* y = root;

  while (y!=NULL && search != y->data)
   {
      if (search < y->data)
    {
      y = y->left;
    }
      else
    {
      y = y->right;
      }
   }

  return y;
}

这是我的上传代码

friend bool operator == (const Students& lh, const Students& rh);
friend bool operator > (const Students& lh, const Students& rh);
friend bool operator < (const Students& lh, const Students& rh);

bool operator ==(const Students& lh, const Students& rh)
{
    return lh.IDnumber == rh.IDnumber;
}

bool operator > (const Students& lh, const Students& rh)
{
    return lh.IDnumber > rh.IDnumber;
}

bool operator < (const Students& lh, const Students& rh)
{
    return lh.IDnumber < rh.IDnumber;
}

这是我创建的树对象

   BST<Students*> stree;              
   BST<int> itree;

Answer 1

如果您使用Students*作为数据类型，那么：

if (search < y->data)

比较指针而不是实际对象。将Student的对象按值传递给BST：

BST<Students> stree;

此外，不要将值逐个传递给运算符和搜索函数：

bool Students::operator< (const Students& ob)
TNode<DataType>* BST<DataType>::bstSearch(const DataType& search)

接下来您应该注意的是，您不需要单独实现所有比较运算符，仅仅实现operator<就足够了。例如：

bool operator==(const some_class& b){ return !(*this < b) && !(b < *this); }
bool operator>(const some_class& b){ return !(*this == b) && !(*this < b); } 
// and so on...

另一方面，您可以使用模板std::enable_if和std::is_pointer自动取消引用指针：

#include <utility>
#include <iostream>

template<typename T>
T& dereference(T &v){return v;}

template<typename T>
const T& dereference(const T& v){return v;}

template<typename T>
typename std::enable_if<!std::is_pointer<T>::value, T&>::type dereference(T* v){return dereference(*v);}

// example usage:
template <typename T>
class A
{
public:
         bool compare(T a, T b){
                return dereference(a) < dereference(b);
        }


};

int main()
{

        int u = 10;
        int *v = &u;

        int i = 5;
        int *j = &i;


        A<int> a;
        A<int*> b;

        std::cout << a.compare(i, u) << std::endl;
        std::cout << b.compare(j, v) << std::endl;

        return 0;

}

所以，只需添加dereference模板，然后在search函数中将其用作：

template <class DataType>
TNode<DataType>* BST<DataType>::bstSearch(DataType search)
{
 TNode<DataType>* y = root;

  while (y!=NULL && dereference(search) != dereference(y->data))
   {
      if (dereference(search) < dereference(y->data))
    {
      y = y->left;
    }
      else
    {
      y = y->right;
      }
   }

  return y;
}

有关取消引用方法的更多信息，请参阅此处我的问题的优秀答案：Recursively dereference pointer

Answer 2

如果你想让它成为一个指针树，你想要比较如下：

if (*search < *(y->data)) {

我看到它的方式，int是非指针类型，Students*是指针类型。
如果您在树中使用Students而不是Students*，则应该可以使用或者，您可以使用不同的实现来处理指针树。

运算符使用二叉搜索树重载

2 个答案: