Question

关于此计划：

该程序用于实现HashTable。

问题如下：

1＆GT;正在链接... 1＆gt; HashTable.obj：错误LNK2019：无法解析的外部符号“public：int __thiscall HashTable :: remove（class Employee const＆amp;）”（？remove @？$ HashTable @ VEmployee @@@@ QAEHABVEmployee @@@ Z），该符号在函数_wmain中被引用

1＆gt; HashTable.obj：错误LNK2019：无法解析的外部符号“public：int __thiscall HashTable :: contains（class Employee const＆amp;）”（？包含@？$ HashTable @ VEmployee @@@@ QAEHABVEmployee @@ @Z），该符号在函数_wmain中被引用

1＆gt; HashTable.obj：错误LNK2019：无法解析的外部符号“public：void __thiscall HashTable :: display（void）const”（？display @？$ HashTable @ VEmployee @@@@ QBEXXZ），该符号在函数_wmain中被引用 1＆gt; HashTable.obj：错误LNK2019：无法解析的外部符号“public：int __thiscall HashTable :: insert（class Employee const＆amp;）”（？insert @？$ HashTable @ VEmployee @@@@ QAEHABVEmployee @@@ Z），该符号在函数_wmain中被引用

1＆gt; HashTable.obj：错误LNK2019：无法解析的外部符号“public：__thiscall HashTable :: HashTable（int）”（?? 0？$ HashTable @ VEmployee @@@@ QAE @ H @ Z），该符号在函数_wmain中被引用

问题：

我不知道为什么会发生这种情况，因为我在Hash.h中给出了声明并在Hash.cpp中定义了。在这个问题发布之前，我已经通过互联网搜索了答案，但没有答案是我想要的。这就是原因我滥用它时有一些使用模板的特殊方法吗？

Hash.h：

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <list>
#include <string>
#include <cstdlib>
#include <cmath>
#include <algorithm>

using namespace std;

template <class T>
class HashTable
{
    public:
        HashTable(int size = 101);
        int insert(const T& x);
        int remove(const T& x);
        int contains(const T& x);
        void make_empty();
        void display()const;
    private:
        vector<list<T> > lists;
        int currentSize;
        int hash(const string& key);
        int myhash(const T& x);
        void rehash();
};

class Employee
{
    public:
        Employee(){}
        Employee(const string n,int s=0):name(n),salary(s){ }
        const string & getName()const { return name; } 

        bool operator == (const Employee &rhs) const
        {
            return getName() == rhs.getName();
        }

        bool operator != (const Employee &rhs) const
        {
            return !(*this == rhs);
        }

        friend ostream& operator <<(ostream& out,const Employee& e)
        {
            out<<"("<<e.name<<","<<e.salary<<") ";
            return out;
        }

    private:
        string name;
        int salary;
};

Hash.cpp

#include "stdafx.h"
#include "Hash.h"

int nextPrime(const int n);

template <class T> HashTable<T>::HashTable(int size)
{
    lists = vector<list<T> >(size);
    currentSize = 0;
}

template <class T> int HashTable<T>::hash(const string& key)
{ 
    int hashVal = 0;
    int tableSize = lists.size();
    for(int i=0;i<key.length();i++)
        hashVal = 37*hashVal+key[i];
    hashVal %= tableSize;
    if(hashVal < 0)
        hashVal += tableSize;
    return hashVal;
}

template <class T> int HashTable<T>:: myhash(const T& x)
{
    string key = x.getName();
    return hash(key);
}

template <class T> int HashTable<T>::insert(const T& x)
{
    list<T> &whichlist = lists[myhash(x)];
    if(find(whichlist.begin(),whichlist.end(),x) != whichlist.end())
        return 0;
    whichlist.push_back(x);
    currentSize = currentSize + 1;
    if(currentSize > lists.size())
        rehash();
    return 1;
}

template <class T> int HashTable<T>::remove(const T& x)
{
    typename std::list<T>::iterator iter; list<T> &whichlist = lists[myhash(x)];
    iter = find(whichlist.begin(),whichlist.end(),x);
    if( iter != whichlist.end())
    {
        whichlist.erase(iter); 
        currentSize--;
        return 1;
    }
    return 0;
}

template <class T> int HashTable<T>::contains(const T& x)
{
    list<T> whichlist;
    typename std::list<T>::iterator iter;
    whichlist = lists[myhash(x)];
    iter = find(whichlist.begin(),whichlist.end(),x);
    if ( iter != whichlist.end())
        return 1;
    return 0;
}

template <class T> void HashTable<T>::make_empty()
{
    for(int i=0;i<lists.size();i++)
        lists[i].clear();
    currentSize = 0;
    return 0;
}

template < class T > void HashTable < T >::rehash()
{
    vector < list < T > >oldLists = lists;
    lists.resize(nextPrime(2 * lists.size()));
    for (int i = 0; i < lists.size(); i++)
    lists[i].clear();
    currentSize = 0;
    for (int i = 0; i < oldLists.size(); i++) {
    typename std::list < T >::iterator iter = oldLists[i].begin();
    while (iter != oldLists[i].end())
        insert(*iter++);
    }
}

template < class T > void HashTable < T >::display() const const
{
    for (int i = 0; i < lists.size(); i++) {
    cout << i << ": ";
    typename std::list < T >::const_iterator iter = lists[i].begin();
    while (iter != lists[i].end()) {
        cout << *iter << " ";
        ++iter;
    }
    cout << endl;
    }
}

int nextPrime(const int n)
{
    int ret, i;
    ret = n;
    while (1) {
    int flag = 1;
    for (i = 2; i < sqrt((float) ret); i++)
        if (ret % i == 0) {
        flag = 0;
        break;
        }
    if (flag == 1)
        break;
    else {
        ret = ret + 1;
        continue;
    }
    }
    return ret;
}

Hashtable.cpp：

// HashTable.cpp :
// #include "stdafx.h"

#include "Hash.h"
int _tmain(int argc, _TCHAR * argv[])
{
    Employee e1("Tom", 6000);
    Employee e2("Anker", 7000);
    Employee e3("Jermey", 8000);
    Employee e4("Lucy", 7500);
    HashTable < Employee > emp_table(13);
    emp_table.insert(e1);
    emp_table.insert(e2);
    emp_table.insert(e3);
    emp_table.insert(e4);
    cout << "Hash table is: " << endl;
    emp_table.display();
    if (emp_table.contains(e4) == 1)
    cout << "Tom is exist in hash table" << endl;
    if (emp_table.remove(e1) == 1)
    cout << "Removing Tom form the hash table successfully" << endl;
    if (emp_table.contains(e1) == 1)
    cout << "Tom is exist in hash table" << endl;
    else
    cout << "Tom is not exist in hash table" << endl;
    return 0;
}

Answer 1

在我滥用模板时，是否存在使用模板的一些特殊方法的原因？

正。模板类/函数的定义必须可以在每个使用它的翻译单元上访问，换句话说，你不能像你那样将其声明与其定义分开。要解决此限制，只需定义内联模板，即头文件。

引用草案n3485

[temp]第1段

函数模板，类模板的成员函数或静态   每个翻译中都应定义类模板的数据成员   它被隐含地实例化的单位除非   相应的专业化被明确地实例化   一些翻译单位;无需诊断。

Answer 2

模板不是类或函数。模板是一种“模式”   编译器用来生成一系列类或函数。

为了让编译器生成代码，它必须同时看到   模板定义（不仅仅是声明）和具体的   类型/用于“填写”模板的任何内容。例如，如果你是   试图使用Foo，编译器必须同时看到Foo模板   而且你正试图制作一个特定的Foo。

您的编译器可能不记得一个.cpp文件的详细信息   而它正在编译另一个.cpp文件。它可以，但大多数不会和   如果您正在阅读此常见问题解答，那几乎肯定不会。顺便说一句   被称为“单独的编译模型。”

您可以阅读此FAQ，此处为Chinese version
如果需要，请勿在头文件中写using namespace std; 要使用std中的string，请改为编写std::string。
对于构造函数只有一个参数，您可以使用explicit 关键字以避免隐式转换。

错误LNK2019：链接错误

2 个答案: