重载指针数组的比较运算符

Question

我有以下数据结构课程的家庭作业。

使用指针数组设计和实现有序列表类。这个类应该是一个模板。 该模板预计会重载>、< 和== 运算符。

1. 该类应该有一个包含 20 个项目的数组。
2. 在搜索插入新项目的位置时，AddItem 方法应从数组的前面开始。
3. RemoveItem 方法应确保数组中的项目仍然有序且项目之间没有空白点。
4. 该类应包括IsEmpty、IsFull 和MakeEmpty 方法。

我有一个有序列表类的工作实现，但分配说我的模板类应该重载一些比较运算符，我不知道为什么我需要这样做。我已阅读 What are the basic rules and idioms for operator overloading?，但不知道如何在此处应用。

这是我目前的解决方案：

#include <cstddef>
#include <iostream>

using namespace std;

#define LEN 20

template <class T> class orderedList
{
  protected:
    T *arr[LEN] = {}; // Array of pointers
  public:
    void addItem(T item);
    void removeItem(T item);
    bool isEmpty();
    bool isFull();
    void makeEmpty();
    bool operator<(const T& rhs) const;
    bool operator>(const T& rhs) const;
    bool operator==(const T& rhs) const;
};
// Overloaded comparison operators
template <class T> bool orderedList<T>::operator<(const T& rhs) const {
  return this < rhs;
}
template <class T> bool orderedList<T>::operator>(const T& rhs) const {
  return rhs < this;
}
template <class T> bool orderedList<T>::operator==(const T& rhs) const {
  return this == rhs;
}

template <class T> void orderedList<T>::addItem(T item)
{
  T temp1 = item;
  T temp2;
  for (int i=0; i<LEN; i++) {
    if(arr[i] == NULL) {
      arr[i] = new T;
      *arr[i] = temp1;
      return;
    } else if (*arr[i] > item) {
      temp2 = *arr[i];
      *arr[i] = temp1;
      temp1 = temp2;
    } else {
      continue;
    }
  }
  cout << "full error!" << endl;
}
template <class T> void orderedList<T>::removeItem(T item)
{
  int cur = 0;
  while( cur<LEN && arr[cur] != NULL && item > *arr[cur]) {
    cur++;
  }
  if (*arr[cur] == item) {
    while(cur+1<LEN && arr[cur+1] != NULL) {
      *arr[cur] = *arr[cur+1];
      cur++;
    }
    delete arr[cur];
    arr[cur] = NULL;
  } else {
    cout << "not found error!" << endl;
  }
}
template <class T> bool orderedList<T>::isEmpty()
{
  for(int i=0; i<LEN; i++) {
    if (arr[i] != NULL)
      return false;
  }
  return true;
}
template <class T> bool orderedList<T>::isFull()
{
  // Traverse in reverse for speed
  for(int i=LEN-1; i>0; i--) {
    if (arr[i] == NULL)
      return false;
  }
  return true;
}
template <class T> void orderedList<T>::makeEmpty()
{
  for(int i=0; i<LEN; i++) {
    if (arr[i] != NULL) {
      delete arr[i];
      arr[i] = NULL;
    }
  }
}

这似乎有效，但是重载的比较运算符没有做任何特别的事情，我也看不出他们需要这样做的任何理由。我最好的猜测是我应该尝试在比较运算符中包含对 NULL 的检查，但我不确定这是否可能。

Answer 1

免责声明：我无法读懂您导师的想法，以下是我对您作业的最佳解释。

作业希望您实施相等测试。检查任何两件事是否相等应该是直观的。如果两个列表以相同的顺序包含相同的元素，则它们是相等的。将您的列表视为单词，将列表元素视为字母。如果可以比较字母，你会如何判断两个单词是否相同？

作业还希望您实现排序测试< 和>。这可能不太直观，但实际上有一个定义明确的列表排序概念，称为字典排序。同样，将您的列表视为单词，将您的列表元素视为字母。您如何确定字典中任意两个单词中的哪个在另一个之前？这是字典顺序。

比较两个单词是有意义的，但是比较一个单词和一个字母就没有什么意义了。查看您重载的操作员签名。您如何修改它们，使它们更像是比较两个词？