使用自定义命名空间时出现 Linker 错误

Question

我无法运行一段应该具有自定义命名空间的代码。 我已经查看了这里和这里的解决方案，但它们都不适用于我的情况。 如果您能看一下这个并让我知道我缺少什么，我将不胜感激。

我在 VS2015 中收到 MSVCRTD.lib 错误和 linker 错误 (LNK1120)。 我在某处读到这可能是由我在 VS 中使用的项目类型引起的，但是，我已经尝试了 Win32 和 Console，并且在两种方式中都遇到了相同的错误。

#include <fstream>
#include <vector>
#include <string>
#include <sstream>
#include <tuple>
#include <iostream>

#define TABLE_SIZE 1028

namespace indexer
{

    struct MyKeyHash
    {
        unsigned long operator()(const std::string & s) const
        {
            int hash = 7;
            for (int i = 0; i < s.length(); i++)
            {
                hash = hash * 31 + s[i];
            }
            return hash % TABLE_SIZE;
        }
    };

    template <typename K, typename V>
    class HashNode
    {
    public:
        HashNode(const K &key, const V &value) : key(key), value(value), next(NULL) {}

        K getKey() const
        {
            return key;
        }

        V getValue() const
        {
            return value;
        }

        void setValue(V value)
        {
            HashNode::value = value;
        }

        HashNode *getNext() const
        {
            return next;
        }

        void setNext(HashNode *next)
        {
            HashNode::next = next;
        }

    private:
        K key;
        V value;
        HashNode *next;
    };

    template <typename K, typename V, typename F>
    class HashMap
    {
    public:
        HashMap()
        {
            table = new HashNode<K, V> *[TABLE_SIZE]();
        }

        ~HashMap()
        {
            for (int i = 0; i < TABLE_SIZE; ++i)
            {
                HashNode<K, V> *entry = table[i];
                while (entry != NULL)
                {
                    HashNode<K, V> *prev = entry;
                    entry = entry->getNext();
                    delete prev;
                }
                table[i] = NULL;
            }
            delete[] table;
        }

        void get(const K &key, std::vector<V> &value)
        {
            unsigned long hashValue = hashFunc(key);
            HashNode<K, V> *entry = table[hashValue];

            while (entry != NULL)
            {
                if (entry->getKey() == key)
                {
                    value.push_back(entry->getValue());
                }
                entry = entry->getNext();
            }
        }

        void insert(const K &key, const V &value)
        {
            unsigned long hashValue = hashFunc(key);
            HashNode<K, V> *prev = NULL;
            HashNode<K, V> *entry = table[hashValue];

            while (entry != NULL && entry->getKey() == key)
            {
                prev = entry;
                entry = entry->getNext();
            }

            if (entry == NULL)
            {
                entry = new HashNode<K, V>(key, value);
                if (prev == NULL)
                {
                    table[hashValue] = entry;
                }
                else {
                    prev->setNext(entry);
                }
            }
            else {
                entry->setValue(value);
            }
        }

        void remove(const K & key)
        {
            unsigned long hashValue = hashFunc(key);
            HashNode<K, V> *prev = NULL;
            HashNode<K, V> *entry = table[hashValue];

            while (entry != NULL && entry->getKey() != key)
            {
                prev = entry;
                entry = entry->getNext();
            }

            if (entry == NULL)
            {
                return;
            }
            else {
                if (prev == NULL)
                {
                    table[hashValue] = entry->getNext();
                }
                else
                {
                    prev->setNext(entry->getNext());
                }
                delete entry;
            }
        }

    private:
        HashNode<K, V> **table;
        F hashFunc;
    };

    class Indexer
    {
    public:

        int rowCount = 0, columnCount = 0;
        std::string line, word;
        std::vector<std::string> listOfWords;
        std::vector<std::tuple<int, int>> coords;
        HashMap<std::string, std::tuple<int, int>, MyKeyHash> indexTable;

        struct Index
        {
            size_t line;
            size_t col;
        };

        Indexer(const std::string & fileName)
        {
            std::ifstream file("text.txt");
            while (getline(file, line))
            {
                rowCount++;
                std::stringstream ss(line);
                while (ss >> word)
                {
                    columnCount++;
                    listOfWords.push_back(word);
                    std::tuple<int, int> aPair(rowCount, columnCount);
                    coords.push_back(aPair);
                }
            }
            file.close();

            for (int i = 0; i < listOfWords.size(); i++)
            {
                indexTable.insert(listOfWords[i], coords[i]);
            }
        }

        std::vector<Index> GetIndex(const std::string & word)
        {
            std::vector<std::tuple<int, int>> value;
            std::vector<Index> results;
            indexTable.get(word, value);
            for (auto it : value)
            {
                Index anIndex{ std::get<0>(it), std::get<1>(it) };
                results.push_back(anIndex);
            }
            return results;
        }
    };
};


bool Compare(const indexer::Indexer::Index& ind1, const indexer::Indexer::Index& ind2)
{
    if (ind1.line != ind2.line || ind1.col != ind2.col)
        return false;

    return true;

}

bool IndexerTest(const std::string& file_name)
{
    indexer::Indexer indexer(file_name);

    // Test 1:
    {
        auto word_indexes = indexer.GetIndex("word");
        if (word_indexes.size() != 2)
            return false;
        if (!Compare(word_indexes[0], indexer::Indexer::Index{ 1, 6 }))
            return false;

        if (!Compare(word_indexes[1], indexer::Indexer::Index{ 2, 16 }))
            return false;
    }

    // Test 2:
    {
        auto word_indexes = indexer.GetIndex("Word");
        if (word_indexes.size() != 3)
            return false;
        if (!Compare(word_indexes[0], indexer::Indexer::Index{ 1, 1 }))
            return false;

        if (!Compare(word_indexes[1], indexer::Indexer::Index{ 2, 9 }))
            return false;

        if (!Compare(word_indexes[2], indexer::Indexer::Index{ 3, 4 }))
            return false;
    }

    // Test 3:
    {
        auto word_indexes = indexer.GetIndex("fact");
        if (word_indexes.size() != 1)
            return false;
        if (!Compare(word_indexes[0], indexer::Indexer::Index{ 8, 14 }))
            return false;
    }

    // Test 4:
    {
        auto word_indexes = indexer.GetIndex("Little");
        if (word_indexes.size() != 2)
            return false;
        if (!Compare(word_indexes[0], indexer::Indexer::Index{ 3, 29 }))
            return false;
        if (!Compare(word_indexes[1], indexer::Indexer::Index{ 10, 1 }))
            return false;

    }

    // Test 5:
    {
        auto word_indexes = indexer.GetIndex("LOL");
        if (word_indexes.size() != 0)
            return false;
    }

    // Test 6:
    {
        auto word_indexes = indexer.GetIndex("binds");
        if (word_indexes.size() != 1)
            return false;

        if (!Compare(word_indexes[0], indexer::Indexer::Index{ 6, 27 }))
            return false;

    }
    return true;
}

int main()
{
    if (IndexerTest("test.txt"))
        std::cout << "Passed" << std::endl;
    else
        std::cout << "Failed" << std::endl;

    return 0;
}

这是我得到的错误。