我正在做这个项目，我应该使用随机选择的节点创建一个平衡的二叉树，其中节点可以是数学运算符或常量。函数createRandomNode（bool，node *）基本上返回一个随机选择的节点。
问题是，当我在VS中运行这段代码时，它可以很好地运行。但是，当我将它带到Ubuntu时，在else段中执行return retFtn时，返回返回节点的指针值会发生变化。
因此，例如在VS中，树基本上看起来像下面的那样，我使用存储在指针中的地址来表示每个节点：
0x0543b
/ \
0x0544c 0x0456d
/ \ / \
0x0342d 0x0453c 0x665f 0x893a
对于每个节点，我可以在VS中运行时查看其值和标签。但是当在Ubuntu中运行时，返回片刻0x0453c并且递归函数返回到retFtn-＆gt;右（其中retFtn现在是0x0543b，因为0x0544c已经完成），0x0544c变为某个奇怪的地址，我再也看不到该节点的值和标签，虽然我仍然可以在返回0x0453c之前看到它。
以下是相关代码。
node* createRandomTree(int depth, node* parent)
{
if (depth > 1)
{
node* retFtn = createRandomNode(true, parent);
retFtn->left = createRandomTree(depth - 1, retFtn);
retFtn->right = createRandomTree(depth - 1, retFtn);
if (retFtn->parent == NULL)
return retFtn;
}
else
{
node* retFtn = createRandomNode(false, parent);
return retFtn;
}
}
我希望我已经解释清楚了，谢谢你的帮助！ ：）
/ ********************************************** ************ / 编辑：
下面是一个Minimal，Complete和Verifiable示例，它可以在Ubuntu 16.04中重现问题（奇怪的是，在VS中运行时不会出现问题）：
main.cpp中：
#include "node.h"
#include "random.h"
#include <iostream>
int main(int argc, char * const argv[])
{
node* createdTree = createRandomTree(3, NULL);
std::cout << createdTree << endl;
inOrder(createdTree);
}
random.cpp：
#include "random.h"
void inOrder(node* tree)
{
if (!tree)
return;
cout << "(";
inOrder(tree->left);
cout << tree->label;
inOrder(tree->right);
cout << ")";
}
node* createRandomTree(int depth, node* parent)
{
if (depth > 1)
{
node* retFtn = createRandomNode(true, parent); //isOperator==true
retFtn->left = createRandomTree(depth - 1, retFtn);
retFtn->right = createRandomTree(depth - 1, retFtn);
if (retFtn->parent == NULL)
return retFtn;
}
else
{
node* retFtn = createRandomNode(false, parent); //isOperator==true
return retFtn;
}
}
node* createRandomNode(bool isOperator, node* parent)
{
int randn = -1;
node* retFtn = NULL;
if (isOperator)
randn = 1;
else
randn = 0;
switch (randn)
{
case 0:
{
retFtn = new ConstantValueNode(parent);
break;
}
case 1:
{
retFtn = new AddNode(parent);
break;
}
default:
{
cout << "invalid random number\n\n\n";
break;
}
}
return retFtn;
}
random.h
#ifndef random_H
#define random_H
#include "node.h"
node* createRandomNode(bool isOperator, node* parent);
node* createRandomTree(int depth, node* parent);
void inOrder(node* tree);
#endif
node.cpp：
#include "node.h"
/***************/
/*Constant Node*/
/***************/
ConstantValueNode::ConstantValueNode(node* retFtn)
{
left=NULL;
right=NULL;
negate_Or_Not = false;
constVal = rand()% 21 + (-10);
key_value = constVal;
parent = retFtn;
label = "Constant";
};
ConstantValueNode::ConstantValueNode(double preSetVal)
{
left=NULL;
right=NULL;
negate_Or_Not = false;
constVal = preSetVal;
key_value = constVal;
label = "Constant";
};
double ConstantValueNode::eval(map<string,double> inputMapping)
{
if (negate_Or_Not) //negation is true
return !constVal;
else
return constVal;
}
ConstantValueNode* ConstantValueNode::clone(node* parent_clone)
{
ConstantValueNode* retTree = new ConstantValueNode(key_value);
if (parent_clone != NULL)
retTree->parent = parent_clone;
else
retTree->parent = NULL;
return retTree;
}
string ConstantValueNode::getLabel()
{
return label;
}
/**********/
/*Add Node*/
/**********/
AddNode::AddNode()
{
label = "AddNode";
negate_Or_Not = NULL; //will be false by default
}
AddNode::AddNode(node* retFtn)
{
label = "AddNode";
negate_Or_Not = NULL;
parent = retFtn;
}
double AddNode::eval(map<string,double> inputMapping)
{
if (left && right)
return left->eval(inputMapping) + right->eval(inputMapping);
else
{
cout << "left and right not defined in add"<<endl;
return -1.0;
}
}
AddNode* AddNode::clone(node* parent_clone)
{
AddNode* retNode = new AddNode();
retNode->left = left->clone(retNode);
retNode->right = right->clone(retNode);
if (parent_clone != NULL)
retNode->parent = parent_clone;
else
retNode->parent = NULL;
return retNode;
}
string AddNode::getLabel()
{
return label;
}
node.h：
#ifndef Node_H
#define Node_H
#include<iostream>
#include<map>
using std::string; //This will allow you to use "string" as an unqualified name
//(resolving to "std::string")
using std::cout;
using std::endl;
using std::map;
class node
{
// Virtual function can be overriden and the pure virtual must be implemented.
// virtual void Function() = 0; is a pure virtual. The "= 0" indicates is purity
public:
bool negate_Or_Not;
string label;
int key_value;
node* left;
node* right;
node* parent;
virtual double eval(map<string,double> inputMapping)=0;
virtual node* clone(node* clone)=0;
virtual string getLabel()=0;
};
class ConstantValueNode : public node
{
double constVal;
public:
ConstantValueNode(node* retFtn);
ConstantValueNode(double preSetVal);
virtual double eval(map<string,double> inputMapping);
virtual ConstantValueNode* clone(node* clone);
virtual string getLabel();
};
class AddNode : public node
{
public:
AddNode();
AddNode(node* retFtn);
virtual double eval(map<string,double> inputMapping);
virtual AddNode* clone(node* clone);
virtual string getLabel();
};
#endif
生成文件：
CXX = g++
CXXFLAGS = -Wall -std=c++11
# ****************************************************
main: main.o node.o random.o
$(CXX) $(CXXFLAGS) -o main main.o node.o random.o
main.o: main.cpp node.h random.h
$(CXX) $(CXXFLAGS) -c main.cpp
node.o: node.h
random.o: node.h random.h
答案 0 :(得分：0)
如果您使用createRandomTree(int depth, node* parent)和depth>1致电parent!=NULL，则此功能不会点击任何return语句。因此createRandomTree被执行直到结束，然后控制被传递回调用者，而没有提供保证的返回值。因此，createRandomTree(3, NULL);会导致retFtn->left = createRandomTree(3 - 1, retFtn);，因此随机垃圾会写入retFtn->left。
我强烈建议您多关注编译器警告：
random.cpp：29：1：警告：控制到达非空函数的末尾[-Wreturn-type]
PS你可能会感兴趣为什么它对VS有效。不知道确切的原因（可以通过检查汇编代码进行调查，但我现在既没有环境也不想深入研究它），但一般的答案是＆＃34;偶然的＆＃34;。我看到两种可能的方式：
if (retFtn->parent == NULL)检查丢失为无用（不会改变任何内容）并且成本高昂（由于CPU传送器架构，分支会降低执行速度）retFtn存储在CPU寄存器中以便在函数内和函数退出时进行计算时，看起来好像返回了retFtn。我在MIPS架构上有类似的案例。随时查看确切原因并与我们分享。