在指针数组的链接列表中创建对象时编译错误:C++

Question

***UPDATE****

所以首先，我正在尝试哈希。 为了使其简短，我创建了一个 linkedlsit 类，它接受一个泛型参数。我有一个哈希表类，我试图在其中创建(我相信(一个链接列表指针数组(请记住，链接列表采用通用类型(

所以，在我的哈希表类中，我有一个私有变量，使得

SLL< Entry <string, int> >** list;

其中SLL是我的链表，Entry是保存键(字符串(和值(int(的对象，并绑定以使其成为指针数组。

在哈希表构造函数中，我像这样创建它

list = new SLL<Entry<string, int> > * [this->size]; 

现在在我的代码中，我尝试在我的哈希码函数结束后将 Entry 对象附加到数组中

list[hash]->append(new Entry<string, int>(key, e));

但是它得到这个错误

HashTable.h: In member function 'void HashTable::createEntry(std::string, int)':
HashTable.h:78:53: error: no matching function for call to 'SLL<Entry<std::basic_string<char>, int> >::append(Entry<std::basic_string<char>, int>*)'
list[hash]->append(new Entry<string, int>(key, i));

如果我将 Entry 作为链接列表中的对象替换为 int、浮点数甚至字符串，它可以工作

那么是什么原因造成的呢？ 请并感谢您，如果您需要更多信息，请告诉我:)

#ifndef SLL_H
#define SLL_H
 template <class T>
class SLL 
{
private:
    Node<T>* head;
    Node<T>* tail;
    int size;
public:
    SLL();
    virtual ~SLL();
    void append(T&);
    void append(T*);
    void prepend(T);
    void deleteElem(int);
    void toString();
    int getSize();
    void insertAt(T, int);
    T retrieveDataAt(int);
 };
 #endif /* SLL_H */
 template <class T>
SLL<T>::SLL() 
 {
this->tail = NULL;
this->head = NULL;
this->size = 0;
}
void SLL<T>::append(T data)
{
//do stuff
        this->head = new Node<T>(data);;
 }

Answer 1

您发布的代码存在一些问题，它只是显示使用模板时，您需要确保所有内容都匹配良好。特别是因为编译器甚至不会关心某些类型的错误直到您实际实例化具有特定类型的模板。

首先是你的类SLL<T>声明了许多成员函数，其中两个是 SLL::append(T&) 和 SLL::append(T*) .问题是在您发布的示例代码，您正在定义的成员函数是 SLL::append(T)，不存在！

第二个原因是，由于new返回指向类型的指针，因此您的代码：

list[hash]->append(new Entry<string, int>(key, e));

相当于

Entry<string, int>* data_ptr = new Entry<string, int>(key, e);
list[hash]->append(data_ptr);

这将查找形式SLL::append(T*) not 的成员函数 SLL::append(T)，并且没有定义这样的函数！

下面是一些应该为你编译的最低限度的工作代码。请注意，我为了简洁起见，使用了std::pair而不是Entry，并且您需要使用 -std=c++11或等效标志(例如 g++ -std=c++11 main.cpp ( 因为我使用了nullptr：

#include <utility>
#include <string>
template<class T>
class SLL;
// singly linked list node
template<class T>
class Node
{
private:
    Node<T> *next;
    T data;
    friend class SLL<T>;
public:
    Node(T input) : next(nullptr),
        data(input) {}
    ~Node() {delete next;}
};
// the singly linked list class
template <class T>
class SLL
{
private:
    Node<T>* head;
    Node<T>* tail;
    std::size_t size;
public:
    SLL() : head(nullptr),
        tail(nullptr), size(0) {}
    ~SLL() {delete head;}
    std::size_t getSize() const {
        return size;}
    void append(T data);
};
template<class T>
void SLL<T>::append(T data)
{
    Node<T> *temp = new Node<T>(data);
    if (!head)
        head = temp;
    if (tail)
        tail->next = temp;
    tail = temp;
    size += 1;
}
int main()
{
    // less typing
    using list_type = SLL<std::pair<std::string, int>>;
    // allocation for the list of lists
    std::size_t hash_size = 10;
    list_type** list_of_lists = new list_type*[hash_size]();
    // data to input
    std::string key = "key";
    int value = 9330323;
    std::size_t hash = 4;
    // check and append
    if (!list_of_lists[hash])
        list_of_lists[hash] = new list_type;
    list_of_lists[hash]->append(std::pair<std::string, int>(key, value));
    // cleanup
    for (std::size_t i = 0; i < hash_size; ++i)
        delete list_of_lists[i];
    delete[] list_of_lists;
}