Question

我有2个类使用带有2个参数的模板，MinHeap和HeapNode。我在main中创建一个MinHeap对象，在类中创建一个向量，之后我调用插入函数，在MinHeap向量中插入一个HeapNode。

在插入方法中出现问题我无法创建HeapNode，因为编译器没有捕获变量类型给我这个错误：

模板参数列表中参数1的

类型/值不匹配'模板类HeapNode'Heap.push_back（HeapNode（key，value））;

主要代码：

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

插入功能代码：

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

HeapNode类代码：

#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类代码：

#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

遗憾的是，您的代码存在问题。

您的主代码会创建一个像这样的最小堆实例：

MinHeap<int,string> vector();

这不会为我建造;视觉工作室的新版本和旧版本的GCC都拒绝了它的各种投诉（你知道most vexing parse，作为一个例子，这种事情会如何绊倒你？）我把它改为< / p>

MinHeap<int, string> v;

这构建了一个MinHeap实例，其私有成员Heap实际上如下所示：

std::vector<int,string> Heap;

现在，如果您查看std::vector的文档，您会发现您在此处所做的是使用分配器创建int的向量string。这不会起作用，你肯定无法将HeapNode实例推到它上面！

你应该做的是：

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

现在，在您的插入功能中，您执行此操作：

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

正如IInspectable所说的那样，对于typeid运算符如何工作的基本误解，以及对模板类型如何工作的误解。 typeid(foo).name()是类型的名称，而不是实际类型本身。这就是为什么您的错误消息显示＆＃34;类型/值不匹配＆＃34;。

您已经知道key的类型和value的类型......他们就在函数原型中！分别为T和V！

如果你这样做：

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

问题消失了。可能存在更多问题，但由于您未在所提供的代码中定义HeapNode和MinHeap的所有功能，因此我无法做到这一点。

获取变量类型名称

1 个答案: