错误调用函数不能转换类型

编写一个类的程序，我试图调用一个函数“构建”我不断收到一个错误说不能不能将参数1从'TreeNode *'转换为'std :: string' Tree和TreeNode的类被写入其他头文件，但被包含在内。 Function构建应该从inorder和preorder创建一棵树排序。主要部分给我们的方式，我们应该写的功能。不需要帮助，试图找出功能，但希望帮助解决这个错误。错误调用函数不能转换类型

template <class Comparable> 
TreeNode<Comparable> *build(Comparable prefix[], Comparable infix[] , int Pi , int Pj , int Ii , int Ij); 

int main() 
{ 

    string in[] = {"Apr", "Aug" ,"Dec", "Feb", "Jul", "Jun", "Mar", "May", "Nov", "Oct",  "Sep"} ; 
    string pre[] = {"Jul", "Feb", "Apr", "Aug", "Dec", "Mar", "Jun", "May", "Sep", "Oct", "Nov"} ; 
    Tree<string> *tree = new Tree<string>(build(pre,in,0,10,0,10)) ; 
} 


TreeNode<Comparable> *build(Comparable prefix[], Comparable infix[] , int Pi , int Pj , int Ii , int Ij) 
{ 
    int preIndex = 0; 
    TreeNode<Comparable> rNode = new TreeNode<Comparable>(prefix[preIndex]); 
    if(Ii > Ij) 
    { 
     return NULL; 
    } 
    if(preIndex>=Pj) 
    { 
     return NULL; 
    } 
    int i =0; 
    for (i=Ii; i<Ij;i++) 
    { 
     if(infix[i]==rNode.item) 
     { 
      break; 
     } 
    } 
    rNode.left=build(Comparable prefix[], Comparable infix[] , int Pi , int Pj , int Ii , int Ij-1); 
    rNode.right=build(Comparable prefix[], Comparable infix[] , int Pi , int Pj , int Ii+1, int Ij);*/ 
}

树节点类

#ifndef _TREENODE_H 
#define _TREENODE_H 

#include <iostream> 
using namespace std; 
template <class Comparable> 

class TreeNode { 

public:  
    Comparable item;   // The data in this node. 
    TreeNode *left; // Pointer to the left subtree. 
    TreeNode *right; // Pointer to the right subtree. 

    TreeNode (Comparable value) 
    { 
     item=value; 
     left=NULL; 
     right=NULL; 
    };  // Constructor. Make a node containing value. 
    TreeNode (Comparable value, TreeNode *leftTree, TreeNode *rightTree) 
    { 
     item=value; 
     left=leftTree; 
     right=rightTree; 
    };// Constructor. 
    template <class Comparable> 
    friend class Tree ; 
}; 
#endif

树类（没有明确的结束）

#ifndef _TREE_H 
#define _TREE_H 

#include <iostream> 
#include "TreeNode.h" 
using namespace std; 

template <class Comparable> 
class Tree{ 
public : 
    TreeNode< Comparable> *root ; 

    Tree() 
    { // dedault constructor 
     root = NULL ; 
    } 

    Tree (Comparable value) // constructor ;create a single node tree 
    { 
     root = new TreeNode<Comparable>(value); 
    }; // constructor   

    Tree(Comparable value , Tree left, Tree right) 
    { 
     root = new TreeNode<Comparable>(value, left, right); 
    }; 
    Tree build(Comparable prefix[], Comparable infix[] , int Pi , int Pj , int Ii , int Ij) 
    { 
    } 
    Tree (Tree &other) // copy constructor 
    { 
     copyTree(other.root, root); 
    }; 

    /*Tree(TreeNode *r) // constructor taking a pointer to a tree node 
    { 
     root=new TreeNode<Comparable>(r->item,r->left,r->right); 
    };*/ 
    Tree & operator = (const Tree &rhs)   // overload assignment operator 
    { 
     copyTree(rhs.root,root); 
    }; 

    ~Tree() // destructor 
    { 
     delete left; 
     delete right; 
    } 



    void preorder() 
    { 
     if(root != NULL) 
     { 
      leftTemp = new TreeNode<Comparable>(root->item,root->left,root->right); 
      rightTemp = new TreeNode<Comparable>(root->item,root->left,root->right); 
      cout<<root->item<<” “; 
      leftTemp=leftTemp->left; 
      preorder(); 
      rightTemp = rightTemp->right; 
      preorder(); 
     } 

    } 
    void postorder() 
    { 
     if(root != NULL) 
     { 
      leftTemp = new TreeNode<Comparable>(root->item,root->left,root->right); 
      rightTemp = new TreeNode<Comparable>(root->item,root->left,root->right); 
      leftTemp=leftTemp->left; 
      postorder(root->left); 
      rightTemp = rightTemp->right; 
      postorder(root->right); 
      cout<<root->item<<” “; 
     } 

    } 
    void inorder() 
    { 
     if(root != NULL) 
     { 
      leftTemp = new TreeNode<Comparable>(root->item,root->left,root->right); 
      rightTemp = new TreeNode<Comparable>(root->item,root->left,root->right); 
      leftTemp=leftTemp->left; 
      inorder(); 
      cout<<root->item<<” “; 
      rightTemp = rightTemp->right; 
      inorder(); 
     } 
    } 

     // the following recursive functions that print the tree node and its level # 

    void preorder(int level) 
    { 
     if(root != NULL) 
     { 
      leftTemp = new TreeNode<Comparable>(root->item,root->left,root->right); 
      rightTemp = new TreeNode<Comparable>(root->item,root->left,root->right); 
      cout<<root->item<<” “<<level<<” “; 
      leftTemp=leftTemp->left; 
      preorder(level+1); 
      rightTemp = rightTemp->right; 
      preorder(level+1); 
     } 
    } 
    void postorder(int level) 
    { 
     if(root != NULL) 
     { 
      leftTemp = new TreeNode<Comparable>(root->item,root->left,root->right); 
      rightTemp = new TreeNode<Comparable>(root->item,root->left,root->right); 
      leftTemp=leftTemp->left; 
      postorder(level+1); 
      rightTemp = rightTemp->right; 
      postorder(level+1); 
      cout<<root->item<<” “<<level<<” “; 
     } 
    } 
    void inorder(int level) 
    { 
     if(root != NULL) 
     { 
      leftTemp = new TreeNode<Comparable>(root->item,root->left,root->right); 
      rightTemp = new TreeNode<Comparable>(root->item,root->left,root->right); 
      leftTemp=leftTemp->left; 
      inorder(level+1); 
      cout<<root->item<<” “<<level<<” “; 
      rightTemp = rightTemp->right; 
      inorder(level+1); 
     } 
    } 

    // the following recursive function prints the tree node with its parent and level number 

    /*void preorder(TreeNode< Comparable> *p , int level) ; // recursive preorder with level # 

    void postorder(TreeNode< Comparable> *p , int level) ; // recursive postorder with level # 

    void inorder(TreeNode< Comparable> *p , int level) ; // recursive inorder with level # 

    void byLevel(); // print the tree by level , use of STL queue class 

    /*int weight() ; // returns the total number of nodes in the tree 

    int height(); // returns the height of the tree 


    // the following three are non-recursive version use of STL stack class 

    /*void pre() ;  // non-recursive preorder 
    void in() ;   // non-recursive inorder() 
    void post() ;  // non-recursive postorder() 


    // static function build2Tree build a nearly perfect balanced binary tree: detail will discuss in class 
    static Tree *build2Tree(Comparable arr [] , int n); */ 
    void copyTree(TreeNode<Comparable>* &copiedTreeRoot, TreeNode<Comparable>* otherTreeRoot) 
    { 
     if(otherTreeRoot == NULL) 
     { 
      copiedTreeRoot = NULL; 
     } 
     else 
     { 
      copiedTreeRoot = new nodeType<Comparable>; 
      copiedTreeRoot->info = otherTreeRoot->info; 
      copyTree(copiedTreeRoot->llink, otherTreeRoot->llink); 
      copyTree(copiedTreeRoot->rlink, otherTreeRoot->rlink); 
     } 
    }//end copyTree 

} ; 
#endif

编辑：添加树/树节点类

来源

2012-10-21 SomeAsianGuy

数据不足。你在哪里返回NULL以外的任何东西？ –

@john比较=模板。它可以是任何东西 –

它的一个函数，使二叉树，所以它返回NULL时，它到达了分支的结尾，并不会继续调用自己构建树 – SomeAsianGuy

你的错误是在这里：

TreeNode<Comparable> rNode = new TreeNode<Comparable>(prefix[preIndex]);

这应该是

TreeNode<Comparable> * rNode = ... 
        ^
        note star

现在让我们来解释一下错误：

在这一行你想从TreeNode<Comparable>*类型的表达构建TreeNode<Comparable>，但似乎TreeNode<Comparable>已经构造，没有标记为explicit，接受std::string。像

template <typename T> 
struct TreeNode 
{ 
TreeNode(const std::string&) {} 
};

编译器来解释你的代码中的唯一可能的方式是投TreeNode<Comparable>到std::string来调用构造函数。但它不能。所以你会得到这样的错误。现在

，你的事业有驴rNode与-> insread的.，因为它成为一个指针。

此外，该代码

rNode.left=build(Comparable prefix[], Comparable infix[] , int Pi , int Pj , int Ii , int Ij-1); 
    rNode.right=build(Comparable prefix[], Comparable infix[] , int Pi , int Pj , int Ii+1, int Ij);*/

看起来无效。它应该是

rNode->left=build(prefix, infix, Pi, Pj, Ii, Ij-1); 
rNode->right=build(prefix, infix, Pi, Pj, Ii+1, Ij);

（我假设它是错字）

当您试图在这里建立Tree同样的事情，在第一点情况：

Tree<string> *tree = new Tree<string>(build(pre,in,0,10,0,10)) ;

build回报你TreeNoed<std::string>，但您的Tree<std::string>有一个构造函数接受std::string（即Comparable）

你可能需要新的构造添加到Tree：

Tree(TreeNode< Comparable>* r):root(r){}

来源

2012-10-21 21:25:27 Lol4t0

即使指针星加入仍然会出现相同的错误 – SomeAsianGuy

@SomeAsianGuy，_完全相同_？ – Lol4t0

是啊改变它仍然得到完全相同的错误 – SomeAsianGuy

Tree (Comparable value) // constructor ;create a single node tree 
    { 
     root = new TreeNode<Comparable>(value); 
    }

这里是你的错误。它期待着一个“字符串”，并且你传递了一个指针。

这里

TreeNode (Comparable value) 
    { 
     item=value; 
     left=NULL; 
     right=NULL; 
    }

同样的事情，期待一个比较的（也就是说是一个字符串），并得到一个树节点*

而且什么是一些功能后，这些分号的？是的，那个接受TreeNode *的注释块。取消注释： - ）

来源

2012-10-21 21:48:53

从我们的老师那里得到一个模范，它就像那个大声笑。 – SomeAsianGuy

@SomeAsianGuy :-)我知道老师可能会很棘手。 :-P但它是学习你知道的重要练习 –

错误调用函数不能转换类型

回答

相关问题