07.内存分区

总结：

数据区包括：堆，栈，全局/静态存储区

全局/静态存储区：常量区，全局区，静态区

常量区包括：字符串常量区，常变量区

代码区：存放程序编译后的二进制代码，不可寻址区

可以说，C/C++内存分区其实只有2个，即代码区和数据区

在没有运行程序前，也就是说程序没有加载到内存前，可执行程序内部已经分好3段信息，分别为代码区（text）、数据区（data）和未初始化数据区（bss）3 个部分

代码区

存放 CPU 执行的机器指令。通常代码区是可共享的（即另外的执行程序可以调用它），使其可共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外地修改了它的指令。另外，代码区还规划了局部变量的相关信息。

全局初始化数据区/静态数据区（data段）

该区包含了在程序中明确被初始化的全局变量、已经初始化的静态变量（包括全局静态变量和局部静态变量）和常量数据（如字符串常量）。

未初始化数据区（又叫 bss 区）

存入的是全局未初始化变量和未初始化静态变量。未初始化数据区的数据在程序开始执行之前被内核初始化为 0 或者空（NULL）。

程序在加载到内存前，代码区和全局区(data和bss)的大小就是固定的，程序运行期间不能改变。然后，运行可执行程序，系统把程序加载到内存，除了根据可执行程序的信息分出代码区（text）、数据区（data）和未初始化数据区（bss）之外，还额外增加了栈区、堆区。

 

代码区（text segment）

加载的是可执行文件代码段，所有的可执行代码都加载到代码区，这块内存是不可以在运行期间修改的。

未初始化数据区（BSS）

加载的是可执行文件BSS段，位置可以分开亦可以紧靠数据段，存储于数据段的数据（全局未初始化，静态未初始化数据）的生存周期为整个程序运行过程。

全局初始化数据区/静态数据区（data segment）

加载的是可执行文件数据段，存储于数据段（全局初始化，静态初始化数据，文字常量(只读)）的数据的生存周期为整个程序运行过程。

栈区（stack）

栈是一种先进后出的内存结构，由编译器自动分配释放，存放函数的参数值、返回值、局部变量等。在程序运行过程中实时加载和释放，因此，局部变量的生存周期为申请到释放该段栈空间。

堆区（heap）

堆是一个大容器，它的容量要远远大于栈，但没有栈那样先进后出的顺序。用于动态内存分配。堆在内存中位于BSS区和栈区之间。一般由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。

#include <iostream>
using namespace std;

int e;
static int f;
int g = 10;
static int h = 10;
int main()
{
	int a;
	int b = 10;
	static int c;
	static int d = 10;
	char *i = "test";
	char *k = NULL;

	cout << "局部未初始化变量====" << &a << endl;
	cout << "局部初始化变量====" << &b << endl;
	cout << "============================" << endl;
	cout << "静态局部未初始化变量====" << &c << endl;
	cout << "静态局部初始化变量====" << &d << endl;
	cout << "============================" << endl;
	cout << "全局未初始化变量====" << &e << endl;
	cout << "全局静态未初始化变量====" << &f << endl;
	cout << "============================" << endl;
	cout << "全局初始化变量====" << &g << endl;
	cout << "全局静态初始化变量====" << &h << endl;
	cout << "============================" << endl;
	cout << "只读数据(文字常量区)====" << &i << endl;
	k = (char *)malloc(10);
	cout << "动态分配的内存====" << k << endl;

	system("pause");
	return EXIT_SUCCESS;
}

输出

局部未初始化变量====012FFDB4
局部初始化变量====012FFDA8
============================
静态局部未初始化变量====003C033C
静态局部初始化变量====003C0008
============================
全局未初始化变量====003C0330
全局静态未初始化变量====003C0338
============================
全局初始化变量====003C0000
全局静态初始化变量====003C0004
============================
只读数据(文字常量区)====012FFD9C
动态分配的内存====屯屯屯屯屯铪

堆排序

#include <iostream>
#include "time.h"
using namespace std;

#define MAX 10

int main()
{
	srand((unsigned int)time(NULL));//随机数种子
	int *p = (int *)malloc(sizeof(int)* MAX);//分配空间
	cout << "===" << sizeof(p) << endl;
	for (int i = 0; i < MAX; i++)
	{
		*(p + i) = rand() % 50;//随机数赋值
		//p[i] = rand() % 50;//随机数赋值另一种方式
		//*p++ = rand() % 50;//这种赋值方式修改了p的值，不可用
	}
	cout << "====排序前==="<< endl;
	for (int i = 0; i < MAX; i++)
	{
		cout << "i=======" << p[i] << endl;
	}
	
	for (int i = 0; i < MAX ; i++)
	{
		for (int j = 0; i < MAX - i - 1; j++)
		{
			if(p[j] > p[j + 1])
			{
				int tmp = p[j];
				p[j] = p[j + 1];
				p[j + 1] = tmp;
			}
		}
	}
	
	cout << "====排序后===" << endl;
	for (int i = 0; i < MAX; i++)
	{
		cout << "i=======" << p[i] << endl;
	}
	free(p);

	system("pause");
	return EXIT_SUCCESS;
}

void *memset(void *s, int c, size_t n);重置内存区域的值一般是设置为0
功能：将s的内存区域的前n个字节以参数c填入
参数：
    s：需要操作内存s的首地址
    c：填充的字符，c虽然参数为int，但必须是unsigned char , 范围为0~255
    n：指定需要设置的大小
返回值：s的首地址

void *memcpy(void *dest, const void *src, size_t n);将src内存内容拷贝到dest上，目标和源内存不能重叠。
功能：拷贝src所指的内存内容的前n个字节到dest所值的内存地址上。
参数：
    dest：目的内存首地址
    src：源内存首地址，注意：dest和src所指的内存空间不可重叠
    n：需要拷贝的字节数
返回值：dest的首地址

memcpy和strcpy比较

memcpy(&arr[2], arr, 20);
	for (int i = 0; i < 10; i++)
	{
		printf("%d\n", arr[i]);
	}
	char arr1[] = { 'h','e','l','l','o' };
	char * p = malloc(100);
	memset(p, 0, 100);
	//1、函数参数不同
	//2、strcpy拷贝字符串 memcpy 可以拷贝一块内存
	//3、拷贝结束标志不同 strcpy \0 memcpy  以个数为结尾
	strcpy(p, arr1);
	memcpy(p, arr1, 5);
	printf("%s\n", p);
	free(p);

memmove()
memmove()功能用法和memcpy()一样，区别在于：dest和src所指的内存空间重叠时，memmove()仍然能处理，不过执行效率比memcpy()低些。如果拷贝源和拷贝目标没有重叠  memcpy和memmove两个函数效率一样

int memcmp(const void *s1, const void *s2, size_t n);
功能：比较s1和s2所指向内存区域的前n个字节
参数：
    s1：内存首地址1
    s2：内存首地址2
    n：需比较的前n个字节
返回值：
    相等：=0
    大于：>0
    小于：<0

#include <iostream>
using namespace std;

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[5] = { 1,2,3,4 };
	int *p = (int *)malloc(sizeof(int)* 10);
	int val = memcmp(arr1, arr2, 20);
	if (!memcmp(arr1, arr2, 8))
	{
		cout << "前两个数组元素内容相同====="  << endl;
	}
	cout << "对比的结果是=====" << val << endl;
	system("pause");
	return EXIT_SUCCESS;
}

输出如下：

前两个数组元素内容相同=====
对比的结果是=====1

#include <iostream>
using namespace std;

int main()
{
	int * p1 =(int *) malloc(sizeof(int)* 10);
	char * p2 = (char *)malloc(sizeof(char)* 40);

	memcpy(p1, "hello", 6);
	memcpy(p2, "hello", 6);
	if (!memcmp(p1, p2, 6))
	{
		cout << "内容相同=====" << endl;
	}
	else
	{
		cout << "内容不相同=====" << endl;

	}
    free(p1);
	free(p2);
	system("pause");
	return EXIT_SUCCESS;
}

输出是：

内容相同=====