调用函数时出错无法转换类型

时间：2012-10-21 21:08:06

标签： c++ templates compiler-errors comparable

为类编写程序并尝试调用函数“build”我不断收到错误，说不能将参数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);*/
}

TreeNode类

#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

编辑：添加了树/ treenode类

2 个答案:

答案 0 :(得分：0)

您的错误在这里：

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

这应该是

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

现在让我们解释错误：

在这一行中，您尝试从类型TreeNode<Comparable>的表达式中构造 TreeNode<Comparable>*，但似乎TreeNode<Comparable>具有构造函数，未标记为{{ 1}}，接受explicit。像

std::string

编译器解释代码的唯一可能方法是将template <typename T> struct TreeNode { TreeNode(const std::string&) {} }; 强制转换为TreeNode<Comparable>以调用该构造函数。但它不能。所以你得到这样的错误。

现在，您必须评估std::string rNode ->的{​​{1}}，因为它已成为指针。

此外，此代码

.

看起来无效。它应该是

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

答案 1 :(得分：0)

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

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

在这里

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

同样的事情，期待一个Comparable（这是一个字符串）并得到一个TreeNode *

还有一些功能后的分号是什么？ 是的，那个接受TreeNode *的注释块。取消注释要知道： - ）

相关问题
最新问题