C++禁止不使用类型的'binaryTreeType'声明

Question

我试着移动这段代码，并且无法通过这个编译错误。我需要将binaryTreeType传递给PostorderTreeEnum的构造函数，因为根指针受到保护，我无法更改或以任何其他方式访问它。任何有关如何声明类型的内容？我曾尝试将BinaryTreeType标头和方法放在第一位，但不修复它。任何帮助都感激不尽！！！！

#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; 
} 

这是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

因为必须声明一个类型才能使用它。现在binaryTreeType在PostorderTreeEnumerator中使用后被声明。您可以通过为binaryTreeType添加前向声明来解决此问题。

template<typename elemType> 
class binaryTreeType; 

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

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