Question

我的操作员问题＆lt;我写道：

Node.h中的

：

.
..
bool operator<(const Node<T>& other) const;
const T& GetData ();
.
..
template <class T>
const T& Node<T>::GetData () {
 return m_data;
}

template <class T>
bool Node<T>:: operator<(const Node<T>& other) const
{
 return (*(this->GetData()) < *(other.GetData()));
}

在Heap.h中：

template<class T>
void Heap<T>::Insert(Node<T>* newNode) {
 if (m_heap.size() == 0) {
  m_heap.push_back(newNode);
 }
 else
  DecreaseKey(newNode);  
}

template<class T>
void Heap<T>::DecreaseKey(Node<T>* newNode) {
 m_heap.push_back(newNode);
 int index = m_heap.size();
 while ((index > 1) && (m_heap[(index/2)-1] < (m_heap[index-1]))) { // doen't do the operator < !
  Exchange(index,index/2);
  index = index/2;
 }
}

在Vehicle.h中：

bool operator< (const Vehicle& otherVehicle) const;

在Vehicle.cpp中：

bool Vehicle::operator<(const Vehicle& otherVehicle) const {
 return (GetDistance() > otherVehicle.GetDistance());
}

在main.cpp中：

..
 Node<Vehicle*> a(car1);
 Node<Vehicle*> b(car2);
 Heap<Vehicle*> heap;
 Node<Vehicle*>* p = &a;
 Node<Vehicle*>* q = &b;
 heap.Insert(p);
 heap.Insert(q);
 heap.ExtractMin()->GetData()->Show();
.
..

为什么它不做竞争？与opeartor＆lt; ，注意：它通过了编译器。

Answer 1

m_heap是一个指针容器。在这种情况下，您应该取消引用节点指针：

while ((index > 1) && (*m_heap[(index/2)-1] < (*m_heap[index-1])))

现在应该针对节点调用operator<，而节点又为车辆调用operator<。

Answer 2

因为您使用了Vehicle *，而不是Vehicle。

Answer 3

使用std :: priority_queue代替Heap，或使用任何其他允许您定义自定义比较谓词的堆。

Answer 4

从我看到m_heap存储指向Node的指针

 while ((index > 1) && (m_heap[(index/2)-1] < (m_heap[index-1]))) { // doen't do the operator <

我想这应该做

while ((index > 1) && (*(m_heap[(index/2)-1]) < *(m_heap[index-1]))) {

Answer 5

简短回答：不要使用指针。你可能不需要它们。

如果可能，如果使用普通对象，则更容易使这种代码更正确。如果需要使用指针的概念，请使用指针容器类，即作为具有值语义的普通对象传递的包装器，以及可能的自定义重载，例如运算符＆lt;你正在使用，但它在内部隐藏了实现指针。

这样，您不需要处理整个应用程序的指针，只能处理语义相关的指针。

运营商问题＆lt;

5 个答案: