類樹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。

我對此表示懷疑，但他/她也可能希望您創建節點的層次結構，因此您不需要將數據存儲爲通用字符串。