临时指针指向使用向量地址 [英] temporary pointer point to a using vector address

问题描述

我有一个问题，将字符串解析成二叉树。

  struct TreeNode {
 string val; //此节点中的数据。 
 TreeNode * left; //指向左子树。 
 TreeNode * right; //指向右子树。 
}; 
 
 string s =（（OR（AND pass（NOT reject））（AND（NOT pass）reject）））; 
  

我做一些笔划，消除（和），并保留所有的独立部分向量后划片，
aftersplit具有（底部）OR和通过NOT拒绝和不通过拒绝（返回）

  string>后分割
 vector< TreeNode> parsetree; 
 while（！aftersplit.empty（））//做解析
 {
 
 TreeNode * temp = new TreeNode; 
 
 temp-> val = aftersplit.back（）; 
 temp-> left = NULL; 
 temp-> right = NULL; 
 aftersplit.pop_back（）; 
 if（temp-> val ==AND|| temp-> val ==OR|| temp-> val ===>|| temp-> val = =< =>）{
 TreeNode * leftnode = new TreeNode; 
 
 leftnode =& parsetree.back（）; 
 parsetree.pop_back（）; 
 temp-> left = leftnode; 
 TreeNode * rightnode = new TreeNode; 
 
 rightnode =& parsetree.back（）; 
 parsetree.pop_back（）; 
 temp-> right = rightnode; 
 parsetree.push_back（temp）; //不能将temp转换为parsetree 
} 
 else if（temp-> val ==NOT）
 {
 TreeNode * leftnode = new TreeNode; 
 
 leftnode =& parsetree.back（）; 
 parsetree.pop_back（）; 
 temp-> left = leftnode; 
 parsetree.push_back（temp）; 
} 
 else {
 parsetree.push_back（temp）; 
} 
  

}

我处理从右到左的字符串

但是当我运行TreeNode leftnode时，操作符是OR;分配一个地址，该地址首先使用AND的左孩子pass，也就是说，AND指向他在地址0x00007fff6d8da7e0的左孩子，并且新的临时leftnode是分配地址0x00007fff6d8da7e0 too
之后
之前的树就像

  AND）
 / \ 
 / \ 
 pass（NOT）
 / 
 reject 
  

之后，leftnode会分配pass的地址。

 （AND）
 / \ 
 / \ 
（AND）（NOT）
 / \ / 
 / \ / 
（AND）（NOT）reject 
 / \ 
 / \ 
（AND）（NOT）
  




等等，都指向自己，我知道指针可能有问题，不能弄清楚。
请帮助我

解决方案

  if（temp.val ==AND || temp.val ==OR|| temp.val ===>|| temp.val ==< =>）{
 TreeNode leftnode; //在这里出现一个错误
 leftnode = parsetree.back（）; 
 parsetree.pop_back（）; 
 temp.left =& leftnode; 
 TreeNode rightnode; 
 rightnode = parsetree.back（）; 
 parsetree.pop_back（）; 
 temp.right =& rightnode; 
 parsetree.push_back（temp）; 
} 
  

您的变量 leftnode 和 rightnode 具有有限的生命周期。因为它们在 if 的范围内声明，所以一旦你离开它们就会被销毁。意味着他们的地址变得无效！所以，每次，temp.left和temp.right的内容将指向一些垃圾数据。

这实际上是为什么你可以看到多次找到相同的地址：因为上一个对象已被销毁，它被用于存储新数据需要。但是这不是你想要的，因为你想保留你创建的所有对象。

最简单的方法是动态创建 TreeNode 你需要（并相应地修改你的代码的其余部分）：

  TreeNode * leftnode = new TreeNode; 
 TreeNode * rightnode = new TreeNode; 
  

这样，即使在步出了 if 。
但是你不能忘记删除。

I have a question about parsing the string s into a binary tree.

struct TreeNode {
string val;         // The data in this node.
TreeNode *left;   // Pointer to the left subtree.
TreeNode *right;  // Pointer to the right subtree.
};

string s="((OR (AND pass (NOT reject)) (AND (NOT pass) reject)))";

I do some stroke and eliminate the "(" and ")" and keep all the separate part in vector aftersplit, aftersplit has (bottom) OR AND pass NOT reject AND NOT pass reject (back)

vector<string> aftersplit;
vector<TreeNode> parsetree;
while (!aftersplit.empty())//do the parsing 
{

     TreeNode *temp=new TreeNode;

    temp->val=aftersplit.back();
    temp->left=NULL;
    temp->right=NULL;        
    aftersplit.pop_back();
    if(temp->val=="AND"||temp->val=="OR"||temp->val=="=>"||temp->val=="<=>"){
        TreeNode *leftnode = new TreeNode; 

        leftnode=&parsetree.back();
        parsetree.pop_back();
        temp->left=leftnode;
        TreeNode *rightnode = new TreeNode; 

        rightnode=&parsetree.back();
        parsetree.pop_back();
        temp->right=rightnode;
        parsetree.push_back(temp); //can not put the temp into parsetree 
    }
    else if(temp->val=="NOT")
    {
        TreeNode *leftnode = new TreeNode; 

        leftnode=&parsetree.back();
        parsetree.pop_back();
        temp->left=leftnode;
        parsetree.push_back(temp);        
    }
    else {            
        parsetree.push_back(temp);
    }

}

I deal with string s from right to left

however when I run "TreeNode leftnode" when operator is "OR"; the lefenode was allocated an address which is using by first "AND"'s left child "pass", that is to say, the "AND"'s point to his left children at address 0x00007fff6d8da7e0, and the new temporary leftnode's is allocating address 0x00007fff6d8da7e0 too after that before that the tree is like

    (AND)            
       / \        
      /   \       
   pass  (NOT)         
          /          
      reject  

after that leftnode is allocated the address of "pass" it will like

                (AND)            
                 /    \        
                /      \       
              (AND)    (NOT)         
              /    \     /     
             /      \   /          
          (AND) (NOT) reject
         /    \        
        /      \       
     (AND)    (NOT)  

and etc, all point to itself, I know there maybe something wrong with pointer, but I can not figure out. please help me

解决方案

if(temp.val=="AND"||temp.val=="OR"||temp.val=="=>"||temp.val=="<=>"){
    TreeNode leftnode;  //appear a bug here
    leftnode=parsetree.back();
    parsetree.pop_back();
    temp.left=&leftnode;
    TreeNode rightnode;
    rightnode=parsetree.back();
    parsetree.pop_back();
    temp.right=&rightnode;
    parsetree.push_back(temp);  
}

Your variables leftnode and rightnode have a limited lifespan. Since they are declared in the scope of your if, they will be destroyed once you step out of there. Meaning their adresses become invalid ! So, each time, the content of temp.left and temp.right is going to point to some garbage data.

This is actually why you can see that you find the same address multiple times : since the previous object has been destroyed, it is being used to store the new data that you need. But that's not exactly what you want, since you want to preserve all the objects that you've created.

The easiest way would be to dynamically create the TreeNodes you need (and modify the rest of your code accordingly):

TreeNode *leftnode = new TreeNode;
TreeNode *rightnode = new TreeNode;

That way, they will stay valid even after stepping out of the if. You must however not forget to delete them afterwards.

这篇关于临时指针指向使用向量地址的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！