C++ forbids declaration of 'binaryTreeType' with no type

Question

I've tried moving this code around all over and I cannot get past this compile error. I need to pass the binaryTreeType into the constructor for PostorderTreeEnum because the root pointer is protected and I cannot change that or access it any other way. Any insite on how to declare the type? I have tried putting the BinaryTreeType header and methods first but that doesn't fix it either. Any help will be much appreciated!!!!

#ifndef H_binaryTree
#define H_binaryTree

#include <iostream>
#include <stack>

using namespace std;

     //Definition of the node
template<class elemType>
struct nodeType
{
   elemType info;
   nodeType<elemType> *llink;
   nodeType<elemType> *rlink;
};

template<class elemType>
class PostorderTreeEnumerator
{
public:
PostorderTreeEnumerator(const binaryTreeType<elemType> *&otherTree);

elemType nextElement();

bool hasMoreElements();

void slideLeft();

void reset();

//friend class binaryTreeType<elemType>;

private:
stack<nodeType<elemType>* > st;


};

template<class elemType>
PostorderTreeEnumerator<elemType>::PostorderTreeEnumerator(const binaryTreeType<elemType> *&otherTree)
{
    slideLeft(this -> root);
}

template<class elemType>
elemType PostorderTreeEnumerator<elemType>::nextElement()
{
    nodeType<elemType> *current, parent;
    st.pop(&current);

    if (!st.isEmpty())
    {
       st.pop(parent);
       if(parent -> rlink != current)
        slideleft(parent -> rlink); 
    }  
}

template<class elemType>
bool PostorderTreeEnumerator<elemType>::hasMoreElements()
{
    return st.isEmpty();
}

template<class elemType>
void PostorderTreeEnumerator<elemType>::slideLeft()
{
  nodeType<elemType> *current;
  current = this -> root;

  while(current != NULL)
  {  
    st.push(current);
    current = current->llink;
  }
  if(st.isEmpty())
    return;
  st.pop(current);
  if(current->rlink != NULL)
    slideleft(current->rlink);
}

template<class elemType>
void PostorderTreeEnumerator<elemType>::reset()
{

}

    //Definition of the class
template <class elemType>
class binaryTreeType
{
public:
    const binaryTreeType<elemType>& operator=
                 (const binaryTreeType<elemType>&);
      //Overload the assignment operator.
    bool isEmpty();
      //Function to determine if the binary tree is empty.
      //Postcondition: Returns true if the binary tree is empty;
      // otherwise, returns false.
    void inorderTraversal();
      //Function to do an inorder traversal of the binary tree.
      //Postcondition: The nodes of the binary tree are output
      // in the inorder sequence.
    void preorderTraversal();
      //Function to do a preorder traversal of the binary tree.
      //Postcondition: The nodes of the binary tree are output
      // in the preorder sequence.
    void postorderTraversal();
      //Function to do a postorder traversal of the binary tree.
      //Postcondition: The nodes of the binary tree are output
      // in the postorder sequence.

    int treeHeight();
      //Function to deteremine the height of the binary tree.
      //Postcondition: The height of the binary tree is returned.
    int treeNodeCount();
      //Function to determine the number of nodes in the
      //binary tree.
      //Postcondition: The number of nodes in the binary tree
      // is returned.
    int treeLeavesCount();
      //Function to determine the number of leaves in the
      //binary tree.
      //Postcondition: The number of leaves in the binary tree
      // is returned.
    void destroyTree();
      //Deallocates the memory space occupied by the binary tree.
      //Postcondition: root = NULL;

void nonRecursiveInTraversal();
void nonRecursivePreTraversal();
void nonRecursivePostTraversal();

    binaryTreeType(const binaryTreeType<elemType>& otherTree);
      //copy constructor

    binaryTreeType();
      //default constructor

    ~binaryTreeType();
      //destructor

void createTree1();

void inorderTraversal(void (*visit) (elemType&));
//Function to do an inorder traversal of the binary tree.
//The parameter visit, which is a function, specifies
//the action to be taken at each node.

PostorderTreeEnumerator<elemType> getPostorderEnumerator();

friend class PostorderTreeEnumerator<elemType>;


protected:
    nodeType<elemType> *root;

private:
    void copyTree(nodeType<elemType>* &copiedTreeRoot,
                  nodeType<elemType>* otherTreeRoot);
      //Function to make a copy of the binary tree to
      //which otherTreeRoot points.
      //Postcondition: The pointer copiedTreeRoot points to
      // the root of the copied binary tree.

    void destroy(nodeType<elemType>* &p);
      //Function to destroy the binary tree to which p points.
      //Postcondition: The nodes of the binary tree to which
      // p points are deallocated.
      // p = NULL.

    void inorder(nodeType<elemType> *p);
      //Function to do an inorder traversal of the binary
      //tree to which p points.
      //Postcondition: The nodes of the binary tree to which p
      // points are output in the inorder sequence.
    void preorder(nodeType<elemType> *p);
      //Function to do a preorder traversal of the binary
      //tree to which p points.
      //Postcondition: The nodes of the binary tree to which p
      // points are output in the preorder sequence.
    void postorder(nodeType<elemType> *p);
      //Function to do a postorder traversal of the binary
      //tree to which p points.
      //Postcondition: The nodes of the binary tree to which p
      // points are output in the postorder sequence.

    int height(nodeType<elemType> *p);
      //Function to determine the height of the binary tree
      //to which p points.
      //Postcondition: The height of the binary tree to which p
      // points is returned.

    int max(int x, int y);
      //Function to determine the larger of x and y.
      //Postcondition: The larger of x and y is returned.

    int nodeCount(nodeType<elemType> *p);
      //Function to determine the number of nodes in the binary
      //tree to which p points.
      //Postcondition: The number of nodes in the binary tree
      // to which p points is returned.

    int leavesCount(nodeType<elemType> *p);
      //Function to determine the number of leaves in the binary
      //tree to which p points.
      //Postcondition: The number of nodes in the binary tree
      // to which p points is returned.

void inorder(nodeType<elemType> *p, void (*visit) (elemType&));
//Function to do an inorder traversal of the binary
//tree, starting at the node specified by the parameter p.
//The parameter visit, which is a function, specifies the
//action to be taken at each node.

PostorderTreeEnumerator<elemType> *postTreeEnum;
};



template<class elemType>
PostorderTreeEnumerator<elemType> binaryTreeType<elemType>::getPostorderEnumerator()
{
return postTreeEnum;
}

Here is the compilation error from sublime.

/Users/jason/dev/CS271/Lab9/binaryTree.h:24: error: expected ',' or '...' before '<' token
/Users/jason/dev/CS271/Lab9/binaryTree.h:24: error: ISO C++ forbids declaration of         'binaryTreeType' with no type
/Users/jason/dev/CS271/Lab9/binaryTree.h:43: error: expected ',' or '...' before '<' token
/Users/jason/dev/CS271/Lab9/binaryTree.h:43: error: ISO C++ forbids declaration of     'binaryTreeType' with no type
[Finished in 1.0s with exit code 1]

Answer 1

Because a type must be declared before it can be used. Right now binaryTreeType is declared after it's used in PostorderTreeEnumerator. You can fix this by adding a forward declaration for binaryTreeType.

template<typename elemType>
class binaryTreeType;

template<class elemType>
class PostorderTreeEnumerator
{
public:
    PostorderTreeEnumerator(const binaryTreeType<elemType> *&otherTree);

    // ... rest of PostorderTreeEnumerator ...
};