Get Variable Typ Name

Question

Ich habe 2 Klassen, die Vorlagen mit 2 Argumente, MinHeap und HeapNode verwenden. Ich erstelle ein MinHeap-Objekt in der Hauptsache, das einen Vektor innerhalb der Klasse erzeugt, und danach rufe ich die Funktion insert auf, die einen HeapNode in den MinHeap-Vektor einfügt.

Das Problem erscheint, wenn in insert-Methode ich keine HeapNode erstellen kann, weil die Variablentypen vom Compiler nicht gefangen gibt mir diesen Fehler:

Typen/Wert Mismatch bei Argumente 1 in der Liste Template-Parameter für ' Template-Klasse HeapNode 'Heap.push_back (HeapNode (Schlüssel, Wert));

Hauptcode:

MinHeap<int,string> vector(); 
vector.insert(2,"Hola"); 

Insert Funktionscode:

void MinHeap<T,V>::insert(T key, V value){ 
Heap.push_back(HeapNode<typeid(key).name(),typeid(value).name()>  
(key,value)); 
} 

HeapNode Klassencode:

#ifndef HEAPNODE_H 
#define HEAPNODE_H 
template <class T, class V> 
class HeapNode { 
public: 
HeapNode(T newKey, V newValue); 
HeapNode(const HeapNode& orig); 
virtual ~HeapNode(); 
T getKey(); 
void setKey(T newKey); 
V getValue(); 
void setValue(V newValue); 
private: 
T key; 
V value; 

}; 

template <class T, class V> 
HeapNode<T,V>::HeapNode(T newKey, V newValue){ 
this->key = newKey; 
this->value = newValue; 
} 

template <class T, class V> 
T HeapNode<T,V>::getKey(){ 
return key; 
} 

template <class T, class V> 
void HeapNode<T,V>::setKey(T newKey){ 
this->key = newKey; 
} 

template <class T, class V> 
V HeapNode<T,V>::getValue(){ 
return value; 

} 
template <class T, class V> 
void HeapNode<T,V>::setValue(V newValue){ 
this->value = newValue; 
} 
#endif /* HEAPNODE_H */ 

MinHeap Klassencode:

#ifndef MINHEAP_H 
#define MINHEAP_H 
#include "HeapNode.h" 
#include <vector> 
#include <iterator> 
#include <typeinfo> 
#include <iostream> 

using namespace std; 
template <class T, class V> 
class MinHeap { 
public: 
    MinHeap(); 
    MinHeap(const MinHeap& orig); 
    virtual ~MinHeap(); 
    T size(); 
    T empty(); 
    void insert(T key,V value); 
    T min(); 
    T minValues(); 
    void removeMin(); 
    void printHeap(); 
    void removeMinAux(T i); 

private: 
    std::vector<T,V> Heap; 
    void swap(HeapNode<T,V>* parent, HeapNode<T,V>* child); 

}; 

/* 
template <class T, class V> 
MinHeap<T,V>::~MinHeap(){ 
    delete Heap; 
}*/ 
template <class T, class V> 
void MinHeap<T,V>::insert(T key, V value){ 
    Heap.push_back(HeapNode<typeid(key).name(),typeid(value).name()>(key,value)); 
} 
template <class T, class V> 
T MinHeap<T,V>::empty(){ 
    return Heap.empty(); 
} 
template <class T, class V> 
T MinHeap<T,V>::size(){ 
    return Heap.size(); 
} 
template <class T, class V> 
T MinHeap<T,V>::min(){ 
    return Heap.front().getKey(); 
} 

template <class T, class V> 
T MinHeap<T,V>::minValues(){ 
    return Heap.front().getValue(); 
} 

template <class T, class V> 
void MinHeap<T,V>::removeMin(){ 
    Heap.front() = Heap.back(); 
    Heap.pop_back(); 
    removeMinAux(0); 
} 

template <class T, class V> 
void MinHeap<T,V>::removeMinAux(T i){ 
    if(Heap.at(i*2+1)== 0){ 
     cout<< "Heap has been reordenated"<<endl; 
    }else{ 
     if(Heap.at(i*2+1).getKey()<Heap.at(i*2+2).getKey()){ 
      swap(Heap.at(i*2+1),Heap.at(i)); 
      removeMinAux(i*2+1); 
     }else{ 
      swap(Heap.at(i*2+2),Heap.at(i)); 
      removeMinAux(i*2+2); 
     } 
    } 


} 
template <class T, class V> 
void MinHeap<T,V>::swap(HeapNode<T,V>* parent, HeapNode<T,V>* child){ 
    T tmp; 
    tmp = *child; 
    *child = *parent; 
    *parent = tmp; 
    delete tmp; 

} 





#endif /* MINHEAP_H */ 


                   ^

Answer 1

Die Probleme mit Ihrem Code laufen leider etwas tief.

Ihr Hauptcode erstellt eine min-Heap Beispiel wie folgt aus:

MinHeap<int,string> vector(); 

Dies würde für mich nicht bauen; eine neue Version von Visual Studio und eine alte Version von GCC abgelehnt beide es mit verschiedenen Beschwerden (sind Sie sich die most vexing parse, als ein Beispiel dafür, wie diese Art der Sache, die Sie oben stolpern kann?) ich es

MinHeap<int, string> v; 

zu

geändert

Dies konstruiert eine MinHeap Instanz mit einem privaten Mitglied Heap die wie folgt aussieht effektiv:

std::vector<int,string> Heap; 

Nun, wenn Sie für std::vector an die Dokumentation aussehen werden Sie sehen, dass, was Sie hier tun, ein Vektor ist die Schaffung von int mit einem Zuweiser von string. Das wird niemals funktionieren, und Sie werden sicherlich nicht in der Lage sein, HeapNode Instanzen darauf zu schieben!

Was Sie getan haben sollten, ist dies:

std::vector<HeapNode<T, V>> Heap; 

nun in Ihrer Insert-Funktion, tun Sie dies:

Heap.push_back(HeapNode<typeid(key).name(),typeid(value).name()> (key,value)); 

die, wie IInspectable oben sagt, ein grundlegendes Missverständnis, wie der Typeid-Operator funktioniert, und auch ein Missverständnis, wie Schablonentypen funktionieren. typeid(foo).name() ist der Name eines Typs, nicht der tatsächliche Typ selbst. Aus diesem Grund lautet Ihre Fehlermeldung "type/value mismatch".

Sie kennen bereits den Typ key und den Typ value ... Sie sind genau dort in der Funktion Prototyp! T bzw. V!

Wenn Sie dies tun:

Heap.push_back(HeapNode<T,V>(key,value)); 

Das Problem geht weg. Es kann weitere Probleme geben, aber da Sie nicht alle Funktionen von HeapNode und MinHeap in Ihrem mitgelieferten Code definiert haben, kann ich nicht viel dagegen tun.