錯誤調用函數不能轉換類型

Question

編寫一個類的程序，我試圖調用一個函數「構建」我不斷收到一個錯誤說不能不能將參數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 

編輯：添加樹/樹節點類

Answer 1

你的錯誤是在這裏：

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){} 

Answer 2

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

這裏是你的錯誤。它期待着一個「字符串」，並且你傳遞了一個指針。

這裏

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

同樣的事情，期待一個比較的（也就是說是一個字符串），並得到一個樹節點*

而且什麼是一些功能後，這些分號的？ 是的，那個接受TreeNode *的註釋塊。取消註釋： - ）