erreur C2664: 'std :: vecteur vide <_Ty> :: push_back (_Ty &&)': ne peut pas convertir le paramètre 1 de 'Node <T> *' à 'Noeud <T> &&'

Question

erreur C2664: « std :: vecteur vide < _Ty>: : push_back (_Ty & &) ': ne peut pas convertir le paramètre 1 de 'Node *' à 'Noeud & &'

s'il vous plaît je besoin d'aide ...

Je créé node.h & heap.h

nœud. 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; 

Dans la principale, j'ai essayé de vérifier et il n'a pas compilé.

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

pourquoi?

Answer 1

Votre fonction Heap<T>::Insert prend Node<T*>*.

m_heap est défini comme un vector<Node<T>>. Vous devez insérer un Node<T*>, pas un Node<T*>*. Heap<T>::Insert devrait prendre son paramètre par référence const, pas par pointeur.

Votre code utilise beaucoup de pointeurs inutilement; ce serait beaucoup plus simple si vous traitiez des références et renvoyiez les choses par valeur plutôt que d'être enchevêtrées avec des pointeurs partout.