C++ 对不完整类型（类）的无效使用

我的二进制搜索树打印代码中有一些错误，我不知道为什么。（底部的错误）

\ifndef MYBSTREE\u H
#定义MYBSTREE\u H
#包括“abstractbstree.h”
#包括“abstractstack.h”
使用名称空间std；
类LinkedStack*head=NULL//第7行
模板
三烯类
{
公众：
T m_数据；
TreeNode*m_右；
TreeNode*m_左；
};
模板
类LinkedStack:公共抽象堆栈
{
公众：
TreeNode*m_数据；
LinkedStack*m_next；
LinkedStack（）
{
if（head！=NULL）
head=新的LinkedStack；
m_数据=0；
m_next=NULL；
}
无效清除（）
{
while（head->m_next！=NULL）
{
LinkedStack*tmp=head->m_next；
head->m_ldata=tmp->m_ldata；
head->m_next=tmp->m_next；
删除tmp；
}
}
无效推送（TreeNode*x）
{
LinkedStack*tmp=新LinkedStack；
tmp->m_数据=m_数据；
tmp->m_next=m_next；
m_数据=x；
m_next=tmp；
}
void pop（）
{
if（isEmpty（））
库特穆（左）；
rh=高度（m_根->m_右）；
如果（左侧>右侧）
返回左侧+1；
其他的
返回rh+1；
}
}
常量T&findMax（）常量
{
TreeNode*p=m_根；
while（p->m_right！=NULL）
p=p->m_右；
返回p；
}
常量T&findMin（）常量
{
TreeNode*p=m_根；
while（p->m_left！=NULL）
p=p->m_左；
返回p；
}
/*
int包含（常数T&x）常数；
*/
无效清除（）
{
删除m_根；
}
无效插入（常数T&x）
{
TreeNode*p=m_根；
做
{  
如果（x==p->m_根）
返回；
else if（xm_数据）
{
如果（p->m_left==NULL）
{
p->m_left=新树节点；
p->m_left->m_data=x；
返回；
}
其他的
p=p->m_左；
}
否则如果（x>p->m_数据）
{
如果（p->m_right==NULL）
{
p->m_right=新树节点；
p->m_right->m_data=x；
返回；
}
其他的
p=p->m_右；
} 
}而（p->m_right！=NULL&&p->m_left！=NULL）；
}
无效删除（常数T&x）
{
if（m_root==NULL）
返回；
TreeNode*q=m_根；
TreeNode*p；
while（q！=NULL）
{
如果（m_根->m_数据==x）
{
删除q；
返回；
}
否则如果（x>q->m_数据）
{
p=q；
q=q->m_右；
}
其他的
{
p=q；
q=q->m_左；
}
}
如果（q->m_left==NULL&&q->m_right==NULL）
{
如果（p==q）
删除p；
else if（p->m_left==q）
{
p->m_left=NULL；
删除q；
}
其他的
{
p->m_right=NULL；
删除q；
}
返回；
}
如果（（q->m_left==NULL&&q->m_right！=NULL）|（q->m_left！=NULL&&q->m_right==NULL））
{
如果（q->m_left==NULL&&q->m_right！=NULL）
{
如果（p->m_左==q）
{
p->m_left=q->m_right；
删除q；
}
其他的
{
p->m_right=q->m_right；
删除q；
}
}
其他的
{
如果（p->m_左==q）
{
p->m_left=q->m_left；
删除q；
}
其他的
{
p->m_right=q->m_left；
删除q；
}
}
返回；
}
如果（q->m_left！=NULL&&q->m_right！=NULL）
{
TreeNode*检查；
选中=q->m_right；
如果（（检查->m_left==NULL）&&（检查->m_right==NULL））
{
q=检查；
删除支票；
q->m_right=NULL；
}
其他的
{
如果（（q->m_right）->m_left！=NULL）
{
TreeNode*m_leftq；
TreeNode*m_leftp；
m_leftp=q->m_right；
m_leftq=（q->m_right）->m_left；
while（m_leftq->m_left！=NULL）
{
m_leftp=m_leftq；
m_leftq=m_leftq->m_left；
}
q->data=m_leftq->data；
删除m_leftq；
m_leftp->m_left=NULL；
}
其他的
{
TreeNode*tmp；
tmp=q->m_右；
q->data=tmp->data；
q->m_right=tmp->m_right；
删除tmp；
}
}
返回；
}
}
void printproorder（）常量
{
链接堆栈；
stack.push（m_root）；//此行
而（！stack.isEmpty（））//此行
{
TreeNode*root=stack.push（）；//此行
stack.pop（）；//这一行
if（root！=NULL）
{
stack.push（root->right）；//此行
stack.push（root->m_left）；//此行
cout m_dataLine
class LinkedStack*head=NULL；
没有意义。如果您想在
LinkedStack
上有一个头，您应该：

将
类
放到此行中
传递正确的类型，因为它是
#ifndef MYBSTREE_H
#define MYBSTREE_H

#include "abstractbstree.h"
#include "abstractstack.h"
using namespace std;

class LinkedStack *head = NULL;           //LINE 7

template<typename T>
class TreeNode
{
  public:
    T m_data;
    TreeNode* m_right;
    TreeNode* m_left;

};


template<typename T>
class LinkedStack: public AbstractStack<TreeNode<T>*>
{
  public:
    TreeNode<T>* m_data;
    LinkedStack *m_next;

    LinkedStack()
    {
      if(head != NULL)
        head = new LinkedStack;
      m_data = 0;
      m_next = NULL;
    }

    void clear()
    {
      while(head -> m_next != NULL)
      {
        LinkedStack *tmp = head -> m_next;
        head -> m_ldata= tmp -> m_ldata;
        head -> m_next = tmp -> m_next;
        delete tmp;
      }
    }


    void push(TreeNode<T>* x)
    {
      LinkedStack *tmp = new LinkedStack;
      tmp -> m_data = m_data;
      tmp -> m_next = m_next;
      m_data = x;
      m_next = tmp;
    }

    void pop()
    {
      if (isEmpty())
        cout<<"Panic! Nothing to pop"<<endl;
      else
      {
        LinkedStack *tmp;
        tmp = m_next;
        m_data = tmp -> m_data;
        m_next = tmp -> m_next;
        delete tmp;
      }
    }

    int& top()
    {
      if (isEmpty())
        cout<<"Panic! List is Empty"<<endl;

        return m_ldata;
    }

    bool isEmpty()
    {
      bool empty = false;

      if (m_next == NULL)
      {
        empty = true;
      }

      return empty;
    }
};

template<typename T>
class MyBSTree:public AbstractBSTree<T>
{
  private:

    TreeNode<T>* m_root;

  public:

    ~MyBSTree()  
    {
      clear();
    }

    MyBSTree()
    {
      m_root -> m_data = T();
      m_root -> m_right = NULL;
      m_root -> m_left = NULL;
    };

    int size() const
    {
        if(m_root==NULL)
          return 0;
        else
          return (size(m_root->m_left)+1+size(m_root->m_right));
    }

    bool isEmpty() const
    {
      if (m_root== NULL)
        return true;

      else
        return false;
    }

    int height() const
    {
      int lh,rh;
      if(m_root==NULL)
      {
        return 0;
      }
      else
      {
        lh = height(m_root->m_left);
        rh = height(m_root->m_right);

        if(lh > rh)
          return lh + 1;
        else
          return rh + 1;
      }
    }

    const T& findMax() const
    {
      TreeNode<T>* p = m_root;
      while(p -> m_right != NULL)
        p = p -> m_right;
      return p;
    }

    const T& findMin() const
    {
      TreeNode<T>* p = m_root;
      while(p -> m_left != NULL)
        p = p -> m_left;
      return p;
    }
/*
    int contains(const T& x) const;
*/
    void clear()
    {
      delete m_root;
    }

    void insert(const T& x)
    {
      TreeNode<T>* p = m_root;

      do
      {  
        if (x == p -> m_root)
          return;
        else if ( x < p->m_data)
        {
          if(p->m_left == NULL)
          {
              p->m_left = new TreeNode<T>;
              p -> m_left -> m_data = x;
              return;
          }
          else
            p = p -> m_left;
        }
        else if( x > p->m_data)
        {
          if(p->m_right == NULL)
          {
            p->m_right = new TreeNode<T>;
            p-> m_right -> m_data = x;
            return;
          }
          else
            p = p -> m_right;
        } 
      }while(p -> m_right != NULL && p -> m_left != NULL);
    }

    void remove(const T& x)
    {
        if(m_root == NULL)
            return;

        TreeNode<T>* q = m_root;
        TreeNode<T>* p;

        while(q != NULL)
        {
            if(m_root->m_data == x)
            {
                delete q;
                return;
            }
            else if(x > q->m_data)
            {
                p = q; 
                q = q->m_right;
            }
            else
            {
                p = q; 
                q = q->m_left;            
            }
        }

        if(q->m_left == NULL && q->m_right == NULL)
        {
            if(p == q)
                delete p;
            else if(p->m_left == q)
            {
                p->m_left = NULL;
                delete q;
            }
            else 
            {
                p->m_right = NULL;
                delete q;
            }
            return;
        }

        if((q->m_left == NULL && q->m_right != NULL) || (q->m_left != NULL && q->m_right == NULL))
        {
            if(q->m_left == NULL && q->m_right != NULL)
            {
                if(p->m_left == q)
                {
                    p->m_left = q->m_right;
                    delete q;
                }
                else
                {
                    p->m_right = q->m_right;
                    delete q;
                }
            }
            else
            {
                if(p->m_left == q)
                {
                    p->m_left = q->m_left;
                    delete q;
                }
                else
                {
                    p->m_right = q->m_left;
                    delete q;
                }
            }
            return;
        }

        if (q->m_left != NULL && q->m_right != NULL)
        {
            TreeNode<T>* check;
            check = q->m_right;
            if((check->m_left == NULL) && (check->m_right == NULL))
            {
                q = check;
                delete check;
                q->m_right = NULL;
            }
            else
            {
                if((q->m_right)->m_left != NULL)
                {
                    TreeNode<T>* m_leftq;
                    TreeNode<T>* m_leftp;
                    m_leftp = q->m_right;
                    m_leftq = (q->m_right)->m_left;
                    while(m_leftq->m_left != NULL)
                    {
                        m_leftp = m_leftq;
                        m_leftq = m_leftq->m_left;
                    }
                    q->data = m_leftq->data;
                    delete m_leftq;
                    m_leftp->m_left = NULL;
                }
                else
                {
                    TreeNode<T>* tmp;
                    tmp = q->m_right;
                    q->data = tmp->data;
                    q->m_right = tmp->m_right;
                    delete tmp;
                }
            }
            return;
        }
    }

    void printPreOrder() const
    {
      LinkedStack stack;
      stack<T>.push(m_root);                           //THIS LINE
      while(!stack.isEmpty())                          //THIS LINE
        {
          TreeNode<T>* root = stack.push();        //THIS LINE
          stack.pop();                             //THIS LINE
          if(root!= NULL)
          {
            stack.push(root->right);           //THIS LINE
            stack.push(root->m_left);          //THIS LINE
            cout << root->m_data << " ";
          }

        }

    }
/*
    void printPostOrder() const;

    void print() const;
    */
};


#endif

MyBSTree.h: In member function âvoid MyBSTree<T>::printPreOrder() constâ:
MyBSTree.h:362:9: error: invalid use of incomplete type âstruct LinkedStackâ
MyBSTree.h:7:7: error: forward declaration of âstruct LinkedStackâ

class LinkedStack *head = NULL;           //LINE 7

template<typename T>
class LinkedStack;

LinkedStack<int> *head = NULL; //int as a typename T