类树vs结构TreeNode

Question

我有两个单独的程序，都处理与中缀和后缀评估表达式树。一个基于结构，而另一个基于类。现在我被困在上面写着我的任务的一部分（类版本）：

“说完createExpressionTree（）方法的实现”

和

“它与您之前的实现非常相似，只不过您将使用”类树“的实例而不是”结构树节点“的实例。”

这两者比以下有更多的内容，但我认为你可以得到事物的要点，所以我问的是：类实现与结构类实现的相似程度如何？我是否可以复制并粘贴以下所示的旧代码并进行微调？我一直在尝试，但在访问私人会员等方面遇到问题。

因此，这里的分类和我createExpressionTree的新版本是应该去用它

#ifndef TREE_H 
#define TREE_H 

#include <vector> 
#include <stack> 
#include <sstream> 
#include <map> 
# define TYPE_NUMBER 0 
# define TYPE_VARIABLE 1 
# define TYPE_OPERATOR 2 



class Tree 
{ 
public: 
Tree(std::string input,Tree *leftSubTree=NULL,Tree *rightSubTree=NULL); 
Tree(const Tree &inTree); //COPY CONSTRUCTOR 
~Tree(); //DESTRUCTOR 

int evaluate(std::map< std::string, int > ipMap); //EVALUATE THE EXPRESSION 
void postOrderPrint(); 
void inOrderPrint(); 

private: 
Tree *leftPtr; 
std::string Op; 
Tree *rightPtr; 
int NodeType; 

}; 

与树类

Tree::Tree(std::string input,Tree *leftSubTree,Tree *rightSubTree){ 
Op = input; 
leftPtr = leftSubTree; 
rightPtr = rightSubTree; 
int num; 
if (input == "+"|input == "-"|input == "*"|input == "/") 
      NodeType = TYPE_OPERATOR; 
else if(std::istringstream(Op)>>num) 
    NodeType = TYPE_NUMBER; 
else 
    NodeType = TYPE_VARIABLE; 
} 
// copy constructor 

Tree::Tree(const Tree &inTree){ 
Op = inTree.Op; 
NodeType = inTree.NodeType; 

if (inTree.leftPtr == NULL){ 
    leftPtr = NULL; 
} 
else { 
    leftPtr = new Tree(*(inTree.leftPtr)); 
} 
if (inTree.rightPtr == NULL){ 
    rightPtr = NULL; 
} 
else { 
    rightPtr = new Tree(*(inTree.rightPtr)); 
} 
} 


// tree destructor 

Tree::~Tree(){ 
std::cout << "Tree destructor called" << std::endl; 

if (leftPtr != NULL) { 
    delete(leftPtr); 
    leftPtr = NULL; 
} 
if (rightPtr != NULL) { 
    delete(rightPtr); 
    rightPtr = NULL; 
} 

} 

#endif 

新createExpressionTree相关的代码，我会喜欢一些帮助与：

void arithmetic_expression::createExpressionTree(std::vector<std::string> expression) 
{ 
std::stack <Tree> localStack; 
std::string Op; 
//Very similar to old implementation 
} 

这里是以前的实施th Ë结构treeNode的，并且在完成前面的createExpressionTree

struct treeNode { 
treeNode *leftPtr;  /* pointer to left subtree */ 
std::string Op;      /* integer data value */ 
treeNode *rightPtr; /* pointer to right subtree */ 
}; 
typedef struct treeNode TreeNode; 
typedef TreeNode * TreeNodePtr; 

以前createExpressionTree

void arithmetic_expression::createExpressionTree(std::vector<std::string> expression) 
{ 
std::stack <TreeNodePtr> localStack; 
std::string Op; 
TreeNodePtr ptr; 

for(int i=0; i<expression.size();i++) 
{ 

    Op = expression[i]; 

    ptr = createNewTreeNode(Op); 

    if(char_is_operator(Op)) 
    { 

     // adding element to right tree 
     if (localStack.empty()) 
     { 
      std::cout<< "Invalid expression: tree not created " << std::endl; 
      topPtr = NULL; 
      return; 
     } 
     else 
     { 
      ptr->rightPtr = localStack.top(); 
      localStack.pop(); 
     } 

     // adding element to left tree 
     if (localStack.empty()) { 
      std::cout<< "Invalid expression: tree not created " << std::endl; 
      topPtr = NULL; 
      return; 
     } 
     else 
     { 
      ptr->leftPtr = localStack.top(); 
      localStack.pop(); 
     } 

    } 
    // pushing element to stack 
    localStack.push(ptr); 
} 

if (localStack.empty()) { 
    std::cout<< "Invalid expression: tree not created " << std::endl; 
    topPtr = NULL; 
} 
else 
{ 
    topPtr = localStack.top(); 
    localStack.pop(); 
    if (!localStack.empty()) { 
     std::cout<< "Invalid expression: tree not created " << std::endl; 
     topPtr = NULL; 
    } 

} 


} 

Answer 1

，我不认为会有（结构和类之间的唯一区别的类和结构的版本有什么区别是类默认情况下是私有数据）。

如果他只是要你单词“结构”变更为“类”，那么你可以通过使用访问修饰符“公共”

实例访问leftPtr/rightPtr：

struct blah 
{ 
    int boringNumbers; 
    string boringStrings; 
}; 

是一样的：

class blah2 
{ 
public: 
    int boringNumbers; 
    string boringStrings; 
}; 

---

不过，他也可能要你设计你的应用程序将更多代码进入课堂。

那至少包括移动功能，如char_is_operator。

我对此表示怀疑，但他/她也可能希望您创建节点的层次结构，因此您不需要将数据存储为通用字符串。