C++ debug和release版本运行结果不一致浅析

最新推荐文章于 2024-07-09 16:51:35 发布
最新推荐文章于 2024-07-09 16:51:35 发布
阅读量1.7k 收藏
点赞数
分类专栏： C++BUG归档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/calculate23/article/details/108559867
版权

问题

最近在写 AVL 树的问题，其中涉及到大量的指针操作。但由于出现了 bug ，在没有修复时出现了单步调试和直接编译运行的结果不一样的情况。大致情况是：单步调试能够根据逻辑把结果运行出来，但是编译运行会出现程序异常中断的情况。

问题代码

#include<iostream>
#include <cmath>
using namespace std;

template<class K,class V>
struct AVLTreeNode{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;

	K _key;
	V _value;
	int  _bf;   //平衡因子

	AVLTreeNode(const K& key,const V& value)
		:_key(key)
		, _value(value)
		, _left(NULL)
		, _right(NULL)
		, _parent(NULL)
		, _bf(0)
	{}
};

template<class K,class V>
class AVLTree{
	typedef AVLTreeNode<K, V> Node;
public:
	AVLTree()
		:_root(NULL)
	{}
	bool Insert(const K& key, const V& value)
	{
		if (_root == NULL)
		{
			_root = new Node(key,value);
			return true;
		}
		Node* cur = _root;
		Node* parent = NULL;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(key,value);
		if (parent->_key > key)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		//更新平衡因子
		//不平衡，则进行旋转
		while (parent)
		{
			if (parent->_right==cur)
				parent->_bf++;
			else
				parent->_bf--;
			//父节点平衡因子为0时，退出（说明父节点的两边高度一样，算路径长度的话都一样，没有影响）
			if (parent->_bf == 0)
				break;
			//父节点平衡因子为1或-1的时候（说明是从0+1或0-1得来的），父节点两边高度不同，故需要继续更新平衡因子
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = cur->_parent;
			}
			//父节点平衡因子为2或-2时，旋转
			else  //(parent->_bf==2||parent->_bf==-2) 旋转
			{
				if (parent->_bf == -2)
				{
					if (cur->_bf == -1)//右单旋
					{
						_RotateR(parent);
					}
					else //(cur->_bf==1) 左右单旋
					{
						_RotateLR(parent);
					}
				}
				else //(parent->_bf==2)
				{
					if (cur->_bf == 1)  //左单旋
					{
						_RotateL(parent);
					}
					else  //(cur->_bf==-1)右左单旋
					{
						_RotateRL(parent);
					}
				}
				break;
			}
		}
	}
	Node* Find(const K& key)
	{
		if (_root == NULL)
			return NULL;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
				cur = cur->_left;
			else if (cur->_key < key)
				cur = cur->_right;
			else
				return cur;
		}
		return NULL;
	}
	bool Remove(const K& key)
	{
		if (_root == NULL)
			return false;

		Node* parent = NULL;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				Node* del;
				if (cur->_right == NULL)
				{
					del = cur;
					if (parent == NULL)
					{
						_root = cur->_left;
						//_root->_bf = 0;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
							parent->_bf++;
						}
						else
						{
							parent->_right = cur->_left;
							parent->_bf--;
						}
					}
					delete del;
				}
				else if (cur->_left == NULL)
				{
					del = cur;
					if (parent == NULL)
					{
						_root = cur->_right;
						_root->_bf = 0;
						cout << "cur : " << cur->_key << endl;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
							parent->_bf++;
						}
						else
						{
							parent->_right = cur->_right;
							parent->_bf--;
						}
					}
					delete del;
				}
				else
				{
					parent = cur;
					Node* left = cur->_right;
					while (left->_left)
					{
						parent = left;
						left = left->_left;
					}
					del = left;
					cur->_key = left->_key;
					cur->_value = left->_value;
					if (parent->_left == left)
					{
						parent->_left = left->_right;
						parent->_bf++;
					}
					else
					{
						parent->_right = left->_right;
						parent->_bf--;
					}

					delete del;
				}
				break;
			}
		}
		if (cur == NULL)
		{
			return false;
		}
		while (parent)
		{
			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				break;
			}
			else //parent->_bf=2||parent->_bf=-2
			{
				if (parent->_bf == -2)
				{
					if (cur->_bf == -1)
						_RotateR(parent);
					else  //cur->_bf=1
						_RotateLR(parent);
				}
				else
				{
					if (cur->_bf == 1)
						_RotateL(parent);
					else
						_RotateRL(parent);
				}
				break;
			}
		}
		return true;
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
	//判断这棵树是否是平衡搜索树
	bool IsBlance()
	{
		return _IsBlance(_root);
	}
protected:
	void _RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR=subL->_right;

		parent->_left = subLR;
		if (subLR != NULL)
		{
			subLR->_parent = parent;
		}
		subL->_right = parent;
		Node* ppNode = parent->_parent;
		parent->_parent = subL;
		if (ppNode == NULL)
		{
			_root = subL;
			subL->_parent = NULL;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
				subL->_parent = ppNode;
			}
			else
			{
				ppNode->_right = subL;
				subL->_parent = ppNode;
			}
		}
		subL->_bf = parent->_bf = 0;
	}

	void _RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL= subR->_left;

		parent->_right = subRL;
		if (subRL != NULL)
		{
			subRL->_parent = parent;
		}

		subR->_left = parent;
		Node* ppNode = parent->_parent;
		parent->_parent = subR;
		if (ppNode == NULL)
		{
			_root = subR;
			subR->_parent = NULL;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
				subR->_parent = ppNode;
			}
			else
			{
				ppNode->_right = subR;
				subR->_parent = ppNode;
			}
		}
		subR->_bf = parent->_bf = 0;
	}

	void _RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL= subR->_left;
		int bf = subRL->_bf;

		_RotateR(parent->_right);
		_RotateL(parent);

		if (bf == 1) //从subRL的右边插入
		{
			parent->_bf = -1;
			subR->_bf = 0;
		}
		else if (bf == -1) //从subRL的左边插入
		{
			parent->_bf = 0;
			subR->_bf = 1;
		}
		else    //(bf=0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
		}
		subRL->_bf = 0;
	}
	void _RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		_RotateL(parent->_left);
		_RotateR(parent);

		if (bf == 1)
		{
			parent->_bf = 0;
			subL->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subL->_bf = 0;
		}
		else   //bf=0
		{
			parent->_bf = 0;
			subL->_bf = 0;
		}
		subLR->_bf = 0;
	}
	bool _IsBlance(Node* root)
	{
		if (root == NULL)
			return true;
		int right = _Height(root->_right);
		int left = _Height(root->_left);
		if (right - left != root->_bf || abs(right - left) >= 2)
		{
			cout << "平衡因子异常" << root->_key << endl;
			return false;
		}
		return _IsBlance(root->_left) && _IsBlance(root->_right);
	}
	int _Height(Node* root)
	{
		if (root == NULL)
			return 0;
		int right = _Height(root->_right);
		int left = _Height(root->_left);
		if (right > left)
			return (right + 1);
		else
			return (left + 1);
	}
	void _InOrder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		else
		{
			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}
	}
protected:
	Node* _root;
};

void Test1()
{
  cout << "Test1 : " << endl;
	int a[9] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	AVLTree<int, int> avl;
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
	{
		avl.Insert(a[i],i);
	}
	avl.InOrder();
	cout<<avl.IsBlance()<<endl;

	AVLTreeNode<int, int>* ret1 = avl.Find(18);
	if (ret1)
		cout << ret1->_key << ":" << ret1->_value << endl;
	else
		cout << "不存在ret1" << endl;

	AVLTreeNode<int, int>* ret2 = avl.Find(1);
	if (ret2)
		cout << ret2->_key << ":" << ret2->_value << endl;
	else
		cout << "不存在ret2" << endl;

	avl.Remove(26);
	avl.Remove(18);
	avl.Remove(15);
	avl.InOrder();

	avl.Remove(3);
	cout << avl.Remove(7) << endl;
	cout << avl.Remove(7) << endl;
	cout << avl.Remove(9) << endl;
	cout << avl.Remove(11) << endl;
	
	avl.InOrder();
	cout << avl.IsBlance() << endl;
	avl.InOrder();
	
	cout << avl.Remove(14) << endl;
	
	cout << avl.Remove(15) << endl;

	
	avl.Remove(9);
	avl.Remove(11);
	avl.Remove(14);
	avl.Remove(15);
	
	cout << avl.Remove(100) << endl;
	avl.Remove(16);
	avl.Remove(18);
	avl.Remove(26);

	avl.InOrder();
}

void Test2()
{
    cout << "Test2 : " << endl;
	int a[10] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	AVLTree<int, int> avl;
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
	{
		avl.Insert(a[i], i);
	}
	avl.InOrder();
	cout << avl.IsBlance() << endl;

	AVLTreeNode<int, int>* ret1 = avl.Find(5);
	if (ret1)
		cout << ret1->_key << ":" << ret1->_value << endl;
	else
		cout << "不存在ret1" << endl;

	AVLTreeNode<int, int>* ret2 = avl.Find(88);
	if (ret2)
		cout << ret2->_key << ":" << ret2->_value << endl;
	else
		cout << "不存在ret2" << endl;

	avl.Remove(14);
	avl.Remove(16);
	avl.Remove(7);
	avl.InOrder();

	avl.Remove(15);
	avl.Remove(6);
	avl.Remove(5);
	cout << avl.Remove(4) << endl;
	avl.Remove(4);
	avl.Remove(3);
	avl.Remove(2);
	avl.Remove(1);
	cout << avl.Remove(100) << endl;
	avl.Remove(7);
	avl.Remove(16);

	avl.InOrder();
}

int main()
{
	Test1();
	cout << endl;
	cout << endl;
	Test2();
	return 0;
}

分析

问题中阐述的两种运行方式分别对应着 debug 和 release 版本的结果，区别在于 release 版本会进行一定的编译优化。

说点题外话，我们再来回顾一个 C/C++ 程序从 .c 文件到 .exe的可执行文件的流程：

预处理,把宏替换
编译,转成汇编代码
汇编,转成二进制代码
链接,生成可执行文件
.c 文件
.i 文件
.s 文件
.o 文件
.exe 文件

其中，编译优化就是在汇编代码中优化一些不必要的操作。例如本代码的问题是出现了访问到已经被 delete 的内存，对于 debug 版本，在访问内存的指针中会通过 ebp 寄存器，而这种方式会允许少量数组越界或者访问非法内存的情况，进而能让程序继续运行；而对于 release 却会优化会省略 ebp 栈基址指针，这样通过一个全局指针访问栈就会造成返回地址错误是程序崩溃，这种指针又称 帧指针。

解决

问题的关键是程序中，被删除的子节点的孩子节点的父亲指针没有正确设置，以及删除后其祖先节点的平衡因子没有调整导致，所修改 Remove 部分代码即可。

参考

  1. C++ debug和release版本的区别及调试技巧
  2. esp和ebp详解
小胡同的诗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ Debug 和 Release 运行结果不同
yangyangyang20092010的专栏
08-22 7344
VS2008 Debug 和 Release 版本程序运行结果不同的可能原因小结
android studio debug模式下和release模式下代码不一样_c++在Debug模式下正确，在Release下错误的坑...
weixin_39867142的博客
12-25 498
c++变量被优化掉的坑今天碰到一个问题，捯饬了好久才意识到问题的所在。在这里给大家分享一下。程度开发的时候一直debug模式编译，发布的时候才用release,这才是这个问题的由来。程序大概是这么写的#include <iostream> #include <thread> using namespace std; static bool is_ok = false; vo...
vc中debug和release的不同
centipede198613的专栏
01-22 1960
在使用VC开发软件的过程中，正当要享受那种兴奋的时候突然发现：release与debug运行结果不一致，甚至出错，而release又不方便调试，真的是当头一棒啊，可是疼归疼，问题总要解决，下面将讲述一下我的几点经验，看看是不是其中之一： 1. 变量。  大家都知道，debug跟release在初始化变量时所做的操作是不同的，debug是将每个字节位都赋成0xcc(注1)，而release的
C++中 Debug和Release的区别
最新发布
GodJhin的博客
07-09 611
在C/C++编程领域，Debug和Release是两种截然不同的编译模式，它们分别服务于不同的开发阶段和目标。Debug模式，通常称为调试版本，是专为开发人员设计的编译模式。在Debug模式下，编译器会尽可能保留源代码的结构和变量信息，以便在调试过程中能够清晰地反映程序的运行状态。在Debug模式下编译并运行此程序，如果a的值被意外修改为0，程序将在断言处中断，并显示错误消息。2.定期测试Release模式：随着开发的进行，应定期在Release模式下测试程序，以确保优化过程没有引入新的问题。
（原）Vs中debug和release结果不一致
weixin_33726943的博客
06-19 346
转载请注明出处： http://www.cnblogs.com/darkknightzh/p/5598091.html 前两天调试程序，出现了一个很蛋疼的问题，debug和release结果不一致。网上很多都说是变量没有初始化，但是我这边变量已经初始化了。 最后仔细检查，找到了debug和release下代码结果不一致的地方。将该部分代码提取并简化，如下所示： 1 int Matri...
C/C++Release和Debug下编译结果不同
wyz980035287的博客
07-17 1826
项目场景： 同份源码C/C++中Release和Debug下编译结果不同 问题描述： 经常有同学问我明明是同一份代码，debug模式下没问题，但是只要release模式下编译就有问题，各种报错各种运行错误等。 原因分析： 首先debug模式和release模式下编译除了编译模式不一样外，其他其实都是一样的。debug模式下可以运行说明源码在debug模式下对应的编译选项下编译没有问题，为什么在release下就不行呢？其实大部分原因是因为我们在写程序时不可避免的需要调用第三方库，而又可能某个第三方库的
关于vs程序debug版本和release版本运行结果不一致
zhaojunwuiris的博客
06-25 4836
最近遇到debug版本和release版本运行结果不一致的问题，记录一下查询的资料以及自己的解决方法。 1.原因分析 造成这种结果的原因通常是自己的代码不正确，一般是以下两种原因造成： （1）对变量的初始化不一致或未初始化。debug是将每个字节位都赋成0xcc(注1)，而release的赋值近似于随机。 （2）内存访问越界，在debug模式下，每块内存前后都有保护字节，就不是大问题，但是...
浅析Debug和Realse
ZWE7616175的博客
08-12 3904
Debug版本通常称为调试版本，通过编译选项的配合，编译的结果通常包含调试信息，可以设置断点、单步调试等，而且不做任何优化，可以使开发人员提供强大的程序调试能力。 Release版本通常称为发布版本，是为了用户的使用，一般发布版本上不允许调试，Release版本通常不包含调试信息，同时进行了各种优化，以期达到代码量最小和效率最高的目的。 Debug版本通常要比Release版本程序慢，特别是在...
浅析C/C++ library
weixin_30876945的博客
09-28 614
1背景 原来跑的好好的进程，重启后没跑多少就挂掉了，奇怪了。经过跟踪，原来是加载了一个.so文件，于是决定学习一下library相关的东东，现在和大家分享一下。 2分类 C/C++library可分为三类：静态库（StaticLibraries）、共享库（sharedLibraries）和动态加载库（dynamicallyloadedDLlibraries）。 静态...
C++/Qt中调用Python模块
u013441358的专栏
08-31 1103
开发环境搭建 作为一种胶水语言，Python 能够很容易地调用 C 、 C++ 等语言，也能够通过其他语言调用 Python 的模块。Python 提供了 C++ 库，使得开发者能很方便地从 C++ 程序中调用 Python 模块。 值得注意的是，Windows平台下的Python提供的静态库接口只支持MSVC编译器。
C++面试整理
csdn609387481的博客
11-07 2931
最近开始准备找实习了，收到某位大佬的指导，说可以上牛客网把相关的面经都刷一遍，记录下考点各个击破。大佬是搞java的，已经把java的刷完了，看了一下觉得很受用，因此也准备刷下c++的。顺带附上大佬的java总结：https://zhuanlan.zhihu.com/p/266362976 ...
Swift5.0 的 Runtime 机制浅析
Z1591090的博客
10-14 1680
导读：你想知道Swift内部对象是如何创建的吗？方法以及函数调用又是如何实现的吗？成员变量的访问以及对象内存布局又是怎样的吗？这些问题都会在这篇文章中得到解答。为了更好的让大家理解这些内部实现，我会将源代码翻译为用C语言表示的伪代码来实现。 前言 Objective-C语言是一门以C语言为基础的面向对象编程语言，其提供的运行时(Runtime)机制使得它也可以被认为是一种动态语言。运行时的特征之一就是对象方法的调用是在程序运行时才被确定和执行的。系统提供的开放接口使得我们可以在程序运行的时候执行方法替换.
c++ release和debug编译后的结果不一致
zhanglehes的专栏
07-23 1229
最近遇到一个问题，c++ release和debug编译后的结果不一致，查了h
C++程序在debug结果正确但release结果错误或两个模式下结果不同
斯坦福的兔子的博客
11-23 3103
今天在运行release工程时发现运行结果出现了-1.#IND00, 1.#INF00 。但是在debug下可以计算出数字。于是在网上查找资料。 尝试了修改配置属性优化方法为已禁用。未果 尝试了修改调试信息格式Zi。未果 尝试了修改代码生成运行库。未果 原因： 最后通过输出变量仔细对比发现是某个函数中的输入参数是一个结构体，而结构体内包含了多个数组，其中有些数组没有被我进行初始化导致的计算错误。 分析： 由于debug模式下保留调试信息并通常自动将结构体内未初始化的变量初始化为0，所以在debug模式下未完
VS中debug和release运行不一致的问题
wantong1017的专栏
10-02 1036
今天遇到一个很奇葩的问题，debug模式和release模式运行过程不一致，debug能跑，release不能跑，感觉很匪夷所思。 检查了一下，变量该初始化都初始化了。 目前不知道是什么问题，继续跟进中……
记一次Debug与Release版程序输出不一致的问题解决
罗伯特祥的博客
04-07 347
在x86平台下无论Debug还是Release都没问题，而在arm平台下Debug版本程序无问题，Release版本程序（-O3编译）发现输出值不正确，怀疑值被篡改，于是在调用前后分别使用。起初怀疑各种变量是不是没有初始化，查了大半天发现也没啥问题，也不可能是内存越界问题，如果是越界，程序早就甭了。
基于C/C++在Debug模式与Release模式下相同的算法计算出来的结果不一样
无奋斗、无青春!
03-10 372
TEA算法踩坑记，在Debug模式与Release模式下相同的算法计算出来的结果不一样。
OpenCV中矩阵类详解之一：Mat
热门推荐
holybin的专栏
01-02 4万+
Mat::eye 返回一个恒等指定大小和类型矩阵。 C++: static MatExpr Mat::eye(int rows, int cols, inttype) C++: static MatExpr Mat::eye(Size size, int type) 参数 rows –的行数。 cols– 的列数。 size –替代矩阵大小规格Size(cols, rows)的方法。
c++，调试与运行结果不一致的一种可能
m0_63986895的博客
07-27 1844
单步调试与运行结果不一致的一种可能
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小胡同的诗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值