关于游戏安全的一个问题不理解？？

Question

```c++
今天遇到了一个关于游戏安全问题，有个老师说
可以通过把数据打乱的方式保证它不会被索到
比如int gold=1000
当我们用CE搜1000时，可能就会找到gold的真实地址，
但是如果我们把gold在内存中的存储方式打乱，比如
gold四个字节，每个字节拆分开，然后把每个字节打乱并将每一份保存起来
当需要显示gold时，再把保存好的一份重新组合就能显示
我知识水平不够，不理解的地方是，当把它重新组合的时候，组合完毕后
不就再内存中有一个完整的gold了吗，不还是能被搜索到？？

Answer 1

• 你可以看下这个问题的回答https://ask.csdn.net/questions/838880
• 我还给你找了一篇非常好的博客，你可以看看是否有帮助，链接：为什么我的交换函数不起作用？
• 除此之外, 这篇博客: 数据结构基础知识点，看完保证期末不挂科！中的 栈 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• 一种可以实现“先进后出”的存储结构
  分类：

  1. 静态栈
  2. 动态栈（链表实现）

  栈的核心操作：

  1. 压栈（入栈）
  2. 出栈
     栈的示意图如下：
     
     为什么不反过来？
     原因：入栈代码确实会更简单，但出栈代码会很复杂，pTop上一个节点会找不到，导致pTop无法指向上一个节点。
     实现代码如下：

  
  #include <stdio.h>
  #include <malloc.h>
  #include <stdlib.h>
  
  typedef struct Node
  {
  	int data;
  	struct Node* pNext;
  
  } NODE,*PNODE;
  
  typedef struct Stack
  {
  	PNODE pTop;
  	PNODE pBottom;
  }STACK,*PSTACK;
  
  void init(PSTACK pS);          //初始化一个栈
  void push(PSTACK pS, int val); //入栈
  bool empty(PSTACK pS);		   //判断栈是否为空
  void traverse(PSTACK pS);	   //遍历一个栈
  bool pop(PSTACK pS, int* pval);//出栈
  void clear_one(PSTACK pS);     //清空栈第一种实现
  void clear_two(PSTACK pS);     //清空栈第二种实现
  
  int main(void) 
  {
  	STACK S;
  	init(&S);
  	traverse(&S);
  	push(&S,1);
  	push(&S,2);
  	push(&S,3);
  	push(&S,4);
  	push(&S,5);
  	push(&S,6);
  	traverse(&S);
  	int i;
  	pop(&S,&i);
  	pop(&S,&i);
  	printf_s("出栈元素是%d", i);
  	pop(&S,&i);
  	pop(&S,&i);
  	traverse(&S);
  	push(&S, 1);
  	push(&S, 2);
  	push(&S, 3);
  	push(&S, 4);
  	push(&S, 5);
  	push(&S, 6);
  	traverse(&S);
  	clear_one(&S);
  	traverse(&S);
  	push(&S, 1);
  	push(&S, 2);
  	push(&S, 3);
  	push(&S, 4);
  	push(&S, 5);
  	push(&S, 6);
  	traverse(&S);
  	clear_two(&S);
  	traverse(&S);
  	return 0;
  }
  
  //初始化一个栈
  void init(PSTACK pS)
  {
  	pS->pTop = (PNODE)malloc(sizeof(NODE));
  	if (NULL== pS->pTop)
  	{
  		printf_s("动态分配内存失败");
  		exit(-1);
  	}
  	else
  	{
  		pS->pBottom = pS->pTop;
  		//将pTop指向的节点的指针域赋空（使其不链着下一个节点）
  		pS->pTop->pNext = NULL;
  	}
  
  }
  
  //入栈
  //pS:指向栈的指针
  //val:入栈元素的值
  void push(PSTACK pS, int val)
  {
  	PNODE pNew = (PNODE)malloc(sizeof(NODE));
  	if (NULL== pNew)
  	{
  		printf_s("动态分配内存失败");
  		exit(-1);
  	}
  	pNew->data = val;
  	pNew->pNext = pS->pTop;
  	pS->pTop = pNew;
  	return;
  }
  
  //判断栈是否为空
  bool empty(PSTACK pS)
  {
  	if (pS->pTop == pS->pBottom)
  	{
  		return true;
  	}
  	else
  	{
  		return false;
  	}
  	
  }
  
  //遍历一个栈
  void traverse(PSTACK pS)
  {
  	if (empty(pS))
  	{
  		printf_s("栈为空！");
  		return;
  	}
  	PNODE p = pS->pTop;
  	while (p!=pS->pBottom)
  	{
  		printf_s("%d \n", p->data);
  		p = p->pNext;
  	}
  }
  
  //出栈
  //pS:指向栈的指针
  //pval:出栈元素的指针
  bool pop(PSTACK pS, int* pval)
  {
  	if (empty(pS))
  	{
  		return false;
  	}
  	else
  	{
  		PNODE p = pS->pTop;
  		*pval = p->data;
  		pS->pTop = pS->pTop->pNext;
  		free(p);
  		p = NULL;
  		return true;
  	}
  }
  
  //清空栈第一种实现
  //r为一个指针，永远指向p下一个节点
  void clear_one(PSTACK pS)
  {
  	if (empty(pS))
  	{
  		printf_s("栈为空！");
  		return;
  	}
  	PNODE p = pS->pTop;
  	PNODE r = NULL;
  	while (p!=pS->pBottom)
  	{
  		r = p->pNext;
  		free(p);
  		p = r;
  	}
  	pS->pTop = pS->pBottom;
  	return;
  }
  
  //清空栈第二种实现，比较好理解
  //r用于保存要释放内存的节点
  void clear_two(PSTACK pS)
  {
  	if (empty(pS))
  	{
  		printf_s("栈为空！");
  		return;
  	}
  	PNODE p = pS->pTop;
  	PNODE r = NULL;
  	while (p != pS->pBottom)
  	{
  		r = p;
  		p = p->pNext;
  		free(r);
  		r = NULL;
  	}
  	pS->pTop = pS->pBottom;
  	return;
  }
  

  栈的应用：
  1.函数调用
  2.中断
  3.表达式求值
  4.内存分配
  5.缓冲处理
  6.走迷宫问题

• 您还可以看一下 刘伶华老师的软件测试经典面试题剖析课程中的 你还有什么问题想问？小节, 巩固相关知识点