在指针数组中的linkedlist中创建对象时出现编译错误:C++

Question

***更新****

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

因此，在我的哈希表类中，我有一个私有变量

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

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

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

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

现在在我的代码中，我尝试在hashcode函数结束后将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替换为linkedlist中的jsut（int）或float（float）或甚至string（字符串）中的对象，那么它就会起作用

那么是什么导致了这种情况呢？请并感谢您，如果您需要更多信息，请告诉我：）

#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 声明了许多成员函数，其中两个是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*)的成员函数，而不是sll::append(T)的成员函数，并且没有定义这样的函数！

这里有一些最低限度的工作代码，应该为您编译。请注意，为了简洁起见，我使用了std::pair而不是entry，您需要使用-std=C++11或等效标志（例如g++-std=C++11main.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;
}