无法实例化抽象类，不允许使用抽象类型的对象

头文件编写正确的情况下，在main（）中创建了抽象类型的对象，但是使用对象的时候报错说：不允许使用抽象类型对象，并且无法实例化抽象类

#ifndef _BINARY_TREE_H_
#define _BINARY_TREE_H_

template<class elemType>
class binaryTree {//创建抽象类型
public:
    //基本属性
    virtual int height()const = 0;//高度
    virtual int size()const = 0;//节点总数
    //基本方法
    virtual void clear() = 0;//清空
    virtual bool empty()const = 0;//判空
    virtual void preOrederTraverse()const = 0;//前序遍历
    virtual void inOrderTraverse()const = 0;//中序遍历
    virtual void postOrderTraverse()const = 0;//后序遍历
    virtual void levelOrderTraverse()const = 0;//层次遍历

};
#endif

#ifndef _BINARY_LINKLIST_H_  //跟endef有关，类似开关
#define _BINARY_LINKLIST_H_  //属于框架一体
#include"BinaryTree.h"
#include<iostream>
#include<queue>
#include<stack>
using namespace std;

template <class elemType>//创建模版类<>中的是元素类型
class BinaryLinkList :public binaryTree<elemType> {//调用类型进行编写
private:
    struct Node {
        Node* left, * right;//指向左右分支的指针
        elemType data;//节点的数据域
        Node() :left(NULL), right(NULL) {}//无参构造函数，node结构中，将left与right置为0
        Node(elemType value, Node* l = NULL, Node* r = NULL) {//
            data = value; left = l; right = r;
        }
        ~Node() {}
    };
    enum Tags { Left, Right };//遍历左右分支
    struct StackElement {
        Node* pointer;
        Tags tag;
        StackElement() {}
    };
    Node* root;//二叉树的根结点
    void clear(Node* t);
    int size(Node* t)const;
    int height(Node* t)const;
    int leafNum(Node* t)const;

    void preOrder(Node* t)const;//递归前序
    void inOrder(Node* t)const;//递归中序
    void postOrder(Node* t)const;//递归后序
    void preOrderCreate(elemType flag, Node*& t);//注意：t为引用值
public:
    //基本属性的实现
    BinaryLinkList() {}//构造空二叉树:root(NULL) //BinaryLinkList(char){};
    ~BinaryLinkList() { clear(); }
    bool empty()const { return root == NULL; }
    void clear() { if (root) clear(root); root = NULL; }
    int size()const { return size(root); }
    int height()const { return height(root); }
    int leafNum()const { return leafNum(root); }
    void inOrderTraverse()const { if (root)inOrder(root); }//中序遍历
    void postOrderTraverse()const { if (root)postOrder(root); }//后序遍历
    void levelOrderTraverse()const; //层次遍历
    
    void preOrderTraverse()const { if (root)preOrder(root); }//前序遍历
    void preOrderWithStack()const;//非递归前序遍历
    void inOrderWithStack()const;//非递归中序遍历
    void postOrderWithStack()const;//非递归后序遍历

    void levelOrderCreate(elemType flag);//利用外部节点的层次顺序创建二叉树
    void proOrderCreate(elemType flag) { preOrderCreate(flag, root); }//利用外部节点的前顺序创建二叉树
    void makeTree(const elemType& value, BinaryLinkList& lt, BinaryLinkList& rt) {
        root = new Node(value, lt.root, rt.root);
        lt.root = NULL; rt.root = NULL;
    }
    elemType getRoot()const { return root->data; }//取根节点的值
    elemType getLeft()const { return root->left->data; }//取左叉树的值
    elemType getRight()const { return root->right->data; }//取右叉树的值
};

template<class elemType>
void BinaryLinkList<elemType>::clear(Node* t) {//调用指针指向某叉树
    if (t->left) clear(t->left);
    if (t->right) clear(t->right);
    delete t;
}
template<class elemType>
int BinaryLinkList<elemType>::size(Node* t)const {
    if (t == NULL)return 0;//递归出口，结点为0
    return 1 + size(t->left) + size(t->right);//返回全部的结点数
}
template<class elemType>
int BinaryLinkList<elemType>::height(Node* t)const {
    if (t == NULL)return 0;//递归出口，高度为0
    else {
        int lh = height(t->left), rh = height(t->right);;
        return 1 + ((lh > rh) ? lh : rh);//判断左右节点那个更深，再加上root层得到+1
    }
}
template<class elemType>
int BinaryLinkList<elemType>::leafNum(Node* t)const {
    if (t == NULL)return 0;
    else if ((t->left == NULL) && (t->right == NULL))return 1;
    else return leafNum(t->left) + leafNum(t->right);
}
template<class elemType>
void BinaryLinkList<elemType>::preOrder(Node* t)const {
    if (t) {
        cout << t->data << ' ';
        preOrder(t->left);//前序遍历左分支
        preOrder(t->right);//前序遍历右分支
    }
}
template<class elemType>
void BinaryLinkList<elemType>::inOrder(Node* t)const {
    if (t) {
        inOrder(t->left);
        cout << t->data << ' ';
        inOrder(t->right);
    }
}
template<class elemType>
void BinaryLinkList<elemType>::postOrder(Node* t)const {
    if (t) {
        postOrder(t->left);
        postOrder(t->right);
        cout << t->data << ' ';
    }
}
template<class elemType>
void BinaryLinkList<elemType>::levelOrderTraverse()const {
    queue <Node*> que;//使用STL中的队列
    Node* p = root;
    if (p) que.push(p);//让根节点入队列
    while (!que.empty()) {//队列非空
        p = que.front();//取队首元素
        que.pop();//出队
        cout << p->data << ' ';//访问当前结点
        if (p->left != NULL)que.push(p->left);//左入
        if (p->right != NULL)que.push(p->right);//右入
    }
}
template<class elemType>
void BinaryLinkList<elemType>::preOrderCreate(elemType flag, Node*& t) {
    elemType value;
    cin >> value;
    if (value != flag) {//出口为flag
        t = new Node(value);
        preOrderCreate(flag, t->left);//递归创建左子树
        preOrderCreate(flag, t->right);//递归创建右子树
    }
}
template<class elemType>
void BinaryLinkList<elemType>::levelOrderCreate(elemType flag) {
    queue <Node*> que;
    Node* p;
    elemType value, ldata, rdata;//这是？创建模板性对象之类的吗
    cin >> value;
    if (value != flag) root = new Node(value);//创建根结点
    que.push(root);//入队
    while (!que.empty()) {
        p = que.front(); que.pop();//取队首的元素
        cin >> ldata >> rdata;//输入左右的孩子
        cout << p->data << ' ';
        if (ldata != flag)que.push(p->left = new Node(ldata));
        if (rdata != NULL)que.push(p->right = new Node(rdata));
    }
}
template<class elemType>
void BinaryLinkList<elemType>::preOrderWithStack()const {
    stack<Node*> s;
    Node* p = root;
    while (!s.empty() || p) {
        if (p) {
            s.push(p);//指针入栈
            cout << p->data << ' ';//访问当前结点
            p = p->left;//工作指针指向左子树
        }
        else {
            p = s.top();//获取栈顶元素
            s.pop();//退栈
            p = p->right;//工作指针指向右子树
        }
    }
}
template<class elemType>
void BinaryLinkList<elemType>::inOrderWithStack()const {
    stack<Node*> s;//使用STL中的栈    //STL是个什么啊
    Node* p = root;//工作指针
    while (!s.empty() || p) {//栈是非空的或者p是非空的
        if (p) {
            s.push(p);//压入指针
            p = p->left;//工作指针指向左子树
        }
        else {//左子树访问完毕，转向右子树
            p = s.top();//获取栈顶元素
            s.pop();//退栈
            p = p->right;//访问当前结点
            cout << p->data << ' ';//工作指针指向右子树
        }
    }
}
template<class elemType>
void BinaryLinkList<elemType>::postOrderWithStack()const {
    StackElement element;
    stack <StackElement> s;//使用STL中的栈
    Node* p = root;//工作指针
    while (!s.empty() || p) {
        while (p != NULL) {
            element.pointer = p;
            element.tag = Left;
            s.push(element);
            p = p->left;//沿左子树方向向下周游
        }
        element = s.top();
        s.pop();//取栈顶元素
        p = element.pointer;
        if (element.tag == Left) {//从左子树回来
            element.tag = Right;
            s.push(element);
            p = p->right;
        }
        else {//从右子树回来
            cout << p->data << ' ';//访问当前结点
            p = NULL;
        }
    }
}
#endif

#include<queue>
#include<stack>
#include<iostream>
#include<cstdlib>
#include<cstdio>
#include"BinaryLinkedList.h"
using namespace std;

template<class T>
void testBinaryTree(BinaryLinkList<T>& tree) {
    cout << "输入带外部结点的前序遍历序列(*表示NULL为外部结点)：";
    tree.preOrderCreate('*');
    cout << "高度为：" << tree.height() << endl;
    cout << "规模为：" << tree.size() << endl;
    cout << "叶子数为：" << tree.leafNum() << endl;
    cout << "前序遍历："; tree.postOrderWithStack();
    cout << "\n中序遍历:"; tree.inOrderWithStack();
    cout << "\n后序遍历："; tree.postOrderWithStack();
    cout << "\n层次序遍历："; tree.levelOrderTraverse();
    cout << endl;
}
int main() {
    BinaryLinkList<char> tree;
    testBinaryTree(tree);
    system("pause");
    return 0;
}

这是其他方法正常使用的时候，只有这一个方法报错↓

因为类似这样的方法还有几个，所以我也把它们注释了，然后得到下面的报错↓

我发现格式几乎相同，但是只有这个方法无法被实现，请问为什么会造成这样的报错呢，以及如何解决

（PS：如果在这篇提问里发现什么错误，请提醒我，谢谢，因为我能力不足）

• 可以看下cpp参考手册中的 c++-抽象类