C++ 错误LNK2019未解析的外部符号

在我开始之前，我只想说这是我第一篇关于stackoverflow的文章

我正在为类编写一个二进制搜索树。我完成了一个插入函数，以及一个打印节点的遍历。但是，我遇到了一个错误，无法编译以测试我的树。这是我的.h文件，它是一个模板，所以所有内容都包含在这里

我得到了一个LNK错误，从我读到的，我似乎仍然不明白为什么会发生这种情况

错误3错误LNK2019:未解析的外部符号“private:void\u thiscall main\u dc:：BST:：helperInOrder（struct main\u dc:：Node*&）”（？helperInOrder@$BST@H@主要的_dc@@AAEXAAPAU$Node@H@2@@Z）在函数“public:void\u thiscall main\u dc:：BST:：traversalInOrder（void）”中引用（？traversalInOrder@$BST@H@main_dc@@qaexz）\codingpc\Users\Devyn\Documents\Visual Studio 2013\Projects\2420\u Data\u And\u Algorithm\BinarySearchTree\u Project\u 07\BinarySearchTree\u Project\u 07\Driver.obj BinarySearchTree\u Project\u 07

模板
BST级
{
公众：
BST（）；
~BST（）；//删除删除左、右子级的根
int getSize（）；
作废打印（）；
void erase（T项）；//项是一个整数
无效插入（T项）；
//遍历函数（预序、顺序、后序）
//void traverselPreOrder（）；
无效顺序（）；
void transversalpostorder（）；
私人：
//插入的辅助函数
void insertHelper（节点*&n，T项）；
//遍历辅助函数
无效helperPostOrder（节点*&n）；
作废订单（节点*&n）；
//成员数据
节点*根；
整数大小；
};
模板
BST:：BST（）
{
root=nullptr；
尺寸=0；
}
模板
BST:：~BST（）
{
//删除根；
}
模板
int BST:：getSize（）
{
//返回大小；
//返回树中的元素数
}
模板
void BST:：print（）
{
//预序遍历
//每行打印一个元素
//根据深度缩进（见第505页）
}
模板
void BST:：traversalInOrder（）
{
帮助顺序（根）；
}
模板
作废订单（节点*&nPtr）
{
//树中的某些内容-如果根！=null
if（root！=nullptr）
{
//如果root！=null…如果左子指针！=null，递归调用helper，将ptrs传递给left
如果（nPtr->lchild！=nullptr）
{
助手订单（nPtr->lchild）；
}
//打印当前节点
cout数据；
if（nPtr->rchild！=nullptr）//if right child pointer！=null，递归调用helper，将ptr传递给right
{
HelperOrder（nPtr->rchild）
}           
}
else//else树为空打印输出树为空
{
cout lchild！=nullptr）//如果左子级有一个值，则遍历左一次
{
插入帮助（nPtr->lchild，项目）；
}
其他的
{
nPtr->lchild=新节点（项目）；
}
}
else if（item>nPtr->data）//如果item大于data node，并且rchild中没有任何内容，则创建一个节点
{
if（nPtr->rchild！=nullptr）//如果右子级已经存在，则遍历右一次
{
插入帮助器（nPtr->rchild，项目）；
}
其他的
{
nPtr->rchild=新节点（项目）；
}
}
else//parent没有放置项目的位置
{
cout中缺少类作用域
void helperInOrder（Node*&nPtr）
helperInOrder的定义在哪里？
template <class T>
class BST
{
public:
    BST();
    ~BST(); // delete root that deletes left and right child

    int getSize();
    void print();
    void erase(T item); // item is an integer number
    void insert(T item);

    // Traversal functions (pre-order, in-order, post-order)
    // void traverselPreOrder();
    void traversalInOrder();
    void traversalPostOrder();

private:
    // Helper function for insert
    void insertHelper(Node<T>*& n, T item);

    //Traversal helper functions
    void helperPostOrder(Node<T>*& n);
    void helperInOrder(Node<T>*& n);

    // member data
    Node<T>* root;
    int size;
};

    template <class T>
BST<T>::BST()
{
    root = nullptr;
    size = 0;
}

template <class T>
BST<T>::~BST()
{
    // delete root;
}

template <class T>
int BST<T>::getSize()
{
    // return size;
    // return number of elements in the tree
}

template <class T>
void BST<T>::print()
{
    // pre order traversal
    // print one element per line
    // indent according to the depth (see page 505)
}

template <class T>
void BST<T>::traversalInOrder()
{
    helperInOrder(root);
}

template <class T>
void helperInOrder(Node<T>*& nPtr)
{
    // something in tree - if root != null
    if (root != nullptr)
    {
        // if root != null... if left child pointer != null, recursively call helper, passing ptrs left
        if (nPtr->lchild != nullptr)
        {
            helperInOrder(nPtr->lchild);
        }
        // print out current node
        cout << nPtr->data;
        if (nPtr->rchild != nullptr)// if right child pointer != null, recursively call helper, passing ptrs right
        {
            helperInOrder(nPtr->rchild)
        }           
    }
    else // else tree is empty print out tree is empty
    {
        cout << "The tree is empty" << endl;
    }   
}

template <class T>
void BST<T>::erase(T item)
{
    // erase the occurrence of the item in the tree (there should only be 1 
    // or 0 because there are no dupes)
    // resulting tree should still be a binary search tree (balanced AND full?)
}

template <class T>
void BST<T>::insert(T item)
{
    insertHelper(root, item);
}

template <class T>
void BST<T>::insertHelper(Node<T>*& nPtr, T item) // insert an item into BTS, do not allow duplicate numbers
{
    if (root == nullptr) // if nothing in tree - insert node
    {
        root = new Node<T>(item);
    }
    // if something in tree - check to see if less or greater than node you are on
    else if (item < nPtr->data) // if item is less than data in node and nothing is in lchild, create a node
    {
        if (nPtr->lchild != nullptr) // if left child has a value, traverse left once
        {
            insertHelper(nPtr->lchild, item);
        }
        else
        {
            nPtr->lchild = new Node<T>(item);
        }
    }
    else if (item > nPtr->data) // if item is greater than data node and nothing is in rchild, create a node
    {
        if (nPtr->rchild != nullptr) // if right child already exsists, traverse right once
        {
            insertHelper(nPtr->rchild, item);
        }
        else
        {
            nPtr->rchild = new Node<T>(item);
        }
    }
    else // parent has no place for item to go
    {
        cout << "The input " << item << " has already been added to the tree." << endl;
    }
}