错误 C2664 : 'void std::vector<_Ty>::push_back(_Ty&&)': 无法将参数 1 从 'Node<T> *' 转换为 'Node<T>&&'答案

【问题标题】：error C2664 : 'void std::vector<_Ty>::push_back(_Ty&&)': cannot convert parameter 1 from 'Node<T> *' to 'Node<T>&&'错误 C2664 : 'void std::vector<_Ty>::push_back(_Ty&&)': 无法将参数 1 从 'Node<T> *' 转换为 'Node<T>&&'
【发布时间】：2011-04-14 22:41:20
【问题描述】：

错误 C2664 : 'void std::vector<_ty>::push_back(_Ty&&)': 无法将参数 1 从 'Node *' 转换为 'Node&&'

我需要帮助...

我创建了 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;

在main中，我尝试检查并没有编译。

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

为什么？

【问题讨论】：

带有双下划线的名称（你的包含保护）是reserved identifiers，不要使用它们。
@GMan - 更好的是，使用“#pragma once”
@Steve：虽然这是实现定义的。

标签： c++ visual-c++ stl c2664

【解决方案1】：

您的Heap<T>::Insert 函数采用Node<T*>*。

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

您的代码不必要地使用了很多指针；如果你处理引用并按值返回，而不是到处纠缠指针，那会简单得多。

【讨论】：