错误C2664： '无效的std ::矢量<_Ty> ::的push_back（_Ty &&）'：无法从 '节点<T> *' 转换参数1至 '节点<T> &&'

错误C2664：“无效的std ::矢量< _Ty>：：的push_back（_Ty & &）“：不能从转换参数1 '节点*' 到 '节点& &'错误C2664： '无效的std ::矢量<_Ty> ::的push_back（_Ty &&）'：无法从 '节点<T> *' 转换参数1至 '节点<T> &&'

请我需要帮助...

我创建node.h & heap.h

节点。 h：

#ifndef __NODE_H_ 
#define __NODE_H_ 
#include <string> 
#include <iostream> 
using namespace std; 

template <class T> 
class Node { 
private: 
    Node<T>* m_brother; 
    int m_index; 
    T m_data; 

public: 
    Node (T data); 
    ~Node(); 
    int GetIndex() const; 
    int GetBrother() const; 
    void SetIndex (const int index); 
    void SetBrother (const Node<T>* brother); 
    void SetData (const T& data); 
    bool operator<(const Node<T>& other) const; 
}; 

template <class T> 
Node<T>::Node(T data) { 
    SetData(data); 
} 

template <class T> 
int Node<T>::GetIndex() const { 
    return m_index; 
} 


template <class T> 
int Node<T>::GetBrother() const { 
    return m_brother->GetIndex(); 
} 

template <class T> 
void Node<T>::SetData (const T& data) { 
    m_data = data; 
} 

template <class T> 
void Node<T>::SetBrother(const Node<T>* brother) { 
    m_brother = brother; 
} 

template <class T> 
void Node<T>::SetIndex(const int index) { 
    if (index > 0) 
     m_index = index; 
    else 
     cout <<"ERROR: Index Can't be negative number!"<<endl; 
} 

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

#endif 



heap.h: 

#ifndef __HEAP_H_ 
#define __HEAP_H_ 
#pragma once 
#include <vector> 
#include "Node.h" 
using namespace std; 

template<class T> class Heap { 
public: 
    Heap(); 
    virtual ~Heap(); 
    Node<T> * CreateNode (T data); 
    bool IsEmpty() const; 
    Node<T>* RemoveNode(int indexNode); 
    Node<T>* ExtractMin(); 
    //void AddToHeap(Node<T>* newNode); 
    //void Add(int indexNode); 
    void Insert(Node<T>* newNode); 
    void DecreaseKey (Node<T>* newNode); 
    void Exchange (int indexNode1, int indexNode2); 
    void MinHeapify (int indexNode); 


private: 
    vector<Node<T>> m_heap; 
    int num; 
}; 


template<class T> 
Heap<T>::Heap() { 

} 

template<class T> 
Heap<T>::~Heap() { 
} 

template<class T> 
Node<T>* Heap<T>::CreateNode(T data) { 
    Node<T*>* node(T); 
    return node; 
} 

template<class T> 
bool Heap<T>::IsEmpty() const { 
    return (m_heap.size() == 0); 
} 

template<class T> 
Node<T>* Heap<T>::RemoveNode (int indexNum) { 
    Node<T>* nodeToRemove=NULL; 
    if (indexNum > 0 && indexNum < m_heap.size()) { 
    nodeToRemove = m_heap[indexNum]; 
    m_heap [indexNum] = m_heap [ m_heap.size()-1]; 
    m_heap [m_heap.size()-1] = nodeToRemove; 
    m_heap.pop_back(); 
    MinHeapify(nodeToRemove->GetIndex()); 
    } 
    return nodeToRemove; 
} 

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 > 0) && (m_heap[(index/2)-1] > m_heap[index-1])) { 
     Exchange(index,index/2); 
     index = index/2; 
    } 
} 

template<class T> 
Node<T>* Heap<T>::ExtractMin() { 
    Node<T>* minNode; 
    minNode = m_heap[0]; 
    m_heap[0] = m_heap[m_heap.size()-1]; 
    m_heap.erase(m_heap[m_heap.size()-1]); 
    MinHeapify (0); 
    return minNode; 
} 

template<class T> 
void Heap<T>::Exchange (int indexNode1, int indexNode2) { 
    Node<T>* tmp = m_heap[indexNode1-1]; 
    m_heap[indexNode1-1] = m_heap [indexNode2-1]; 
    m_heap[indexNode2-1] = tmp; 
} 


template<class T> 
void Heap<T>::MinHeapify (int indexNode) { 
    int leftNode = 2*indexNode; 
    int rightNode = 2*indexNode+1; 
    int smallest = indexNode; 
    if ((leftNode < m_heap.size()-1) && (m_heap[leftNode-1]<m_heap[smallest-1])) 
     smallest = leftNode; 
    if ((rightNode < m_heap.size()-1) && (m_heap[rightNode-1]<m_heap[smallest-1])) 
     smallest = rightNode; 
    if (smallest != indexNode) { 
     Exchange (indexNode,smallest); 
     MinHeapify(smallest); 
    } 
} 


#endif;

在主，我试图检查，它没有编译。

int main() { 
Node<Vehicle*> a(car1); 
Heap<Vehicle*> heap; 
Node<Vehicle*>* p = &a; 
heap.Insert(p); 
return 0; 
}

为什么？

来源

2010-09-20 Gil Yosef

带有双下划线的名称（你的包含守卫）是[保留标识符]（http://stackoverflow.com/questions/228783/what-are-the-rules-about-using-an-underscore-in-ac-标识符），请勿使用它们。 – GManNickG 2010-09-21 05:31:44

@GMan - 更好的是，使用'#pragma once' – 2010-09-21 14:52:55

@Steve：虽然这是实现定义的。 – GManNickG 2010-09-21 21:39:02

您的Heap<T>::Insert函数需要Node<T*>*。

m_heap定义为vector<Node<T>>。您需要插入Node<T*>，而不是Node<T*>*。 Heap<T>::Insert应该通过const引用而不是通过指针来接受它的参数。

你的代码不必要地使用了很多指针;如果您处理引用并按价值返回事物，而不是与遍布各处的指针纠缠在一起，那将会简单得多。

来源

2010-09-21 01:34:45

错误C2664： '无效的std ::矢量<_Ty> ::的push_back（_Ty &&）'：无法从 '节点<T> *' 转换参数1至 '节点<T> &&'

回答

相关问题