错误调用功能无法转换类型
Error calling function Can not convert type
为类编写一个程序，并试图调用一个函数"构建"，我会遇到错误，说不能将参数1从'treenode *'转换为std :: string'树和treenode的类写在其他标题文件中，但包括该函数构建应该从inorder和预订排序中创建树。主要部分以这样的方式向我们提供了，我们应该编写该功能。不需要尝试弄清楚该功能，而需要帮助解决此错误。
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 class
#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类
Tree (Comparable value) // constructor ;create a single node tree
{
root = new TreeNode<Comparable>(value);
}
这是您的错误。它期望一个"字符串"，您将指针转向了它。
和这里
TreeNode (Comparable value)
{
item=value;
left=NULL;
right=NULL;
}
同一件事，期待可比（即字符串）并获得treenode *
还可以在功能之后的某些半殖民地？是的，该评论的块接受了treenode *。不知道： - ）
您的错误在这里：
TreeNode<Comparable> rNode = new TreeNode<Comparable>(prefix[preIndex]);
这应该是
TreeNode<Comparable> * rNode = ...
^
note star
现在让我们解释错误：
在这一行中，您正在尝试从类型TreeNode<Comparable>*的表达中 construct TreeNode<Comparable>，但是看来TreeNode<Comparable>具有构造函数，没有标记为explicit，接受std::string。喜欢
template <typename T>
struct TreeNode
{
TreeNode(const std::string&) {}
};
编译器解释您的代码的唯一可能方法是将TreeNode<Comparable>铸造为std::string来调用该构造函数。但是不能。因此您会遇到这样的错误。
现在，您的原因必须用->的rNode CC_8进行评估，因为它变成了 pointer 。。
另外，此代码
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){}
相关文章：
- 无法转换类型 C++
- 包含可变参数包的第一个可转换类型的别名的结构
- 将 std::conditional 与不可转换类型(原始与指针）一起使用
- 链接方法时出现转换类型错误
- 如何避免隐式转换类型
- 在多重继承场景中动态强制转换类型
- 编译器不支持的转换类型
- 错误调用功能无法转换类型
- 我想看到一个在整个后缀表达式的上下文中查找转换类型 id 的示例
- 对于动态类型为强制转换类型的对象，dynamic_cast失败
- 无法在初始化中转换类型
- 如何让"auto"转换类型
- 如何通过强制转换类型指针将字符数组转换为uint16_t
- 如何从新运算符+(Template类）返回具有转换类型的对象
- 带有模板的基于枚举的工厂无法转换类型
- 使用SWIG类型映射通过字符串转换类型
- 对于可转换类型，设计比循环依赖项更好
- SWIG不能正确转换类型定义
- 将类型转换扩展到可转换类型的对/元组
- 想要将字符数组的部分转换/类型转换为值
