C/C++笔记：动态内存分配

1. C语言中的动态内存分配

1.1. malloc

void* malloc(size_t size);

malloc 将为用户分配size字节个内存，并且返回内存分配的地址，如果分配失败，那么返回0。

int * pa = (int*)malloc(4);

• pa 是分配好的内存的地址，4是要分配的大小，如果分配失败, pa = 0。

---

1.2. calloc

void* calloc(size_t count, size_t size);

calloc 将为用户分配count *size字节个内存，并且返回内存分配的地址，如果分配失败，那么返回0。

int * pa = (int*)calloc(1, 4);

• pa 是分配好的内存的地址,1是要分配元素的个数，4是要分配的每个个数的大小，如果分配失败, pa = 0。
• pa 会将分配好的内存区域清零 。

---

1.3. realloc

void* realloc(void* _Block, size_t _Size);

realloc 将为用户重新分配内存，_Block是用户已经分配好的内存，_Size是要重新分配的大小，函数返回重新分配后的内存地址。

int * pa = (int*)malloc(4);
      pa = (int*)realloc(pa, 8);

• pa 是重新分配后的内存的地址,8是重新分配后的大小，如果分配失败, pa = 0。

---

1.4. free

void free(void* _Block);

释放内存，_Block是你要释放的内存地址。

int * pa = (int*)malloc(4);
free(pa);  
pa = 0;

• pa所占用的内存释放。
• 内存释放之后，指针还在的，成为悬挂指针，所以要指针也清零。

---

1.5. memcpy

复制内存。

void* memcpy(void* _Dst, const void* _Src, size_t _Size);

memcpy可以将_Src区域的内存复制到_Dst区域，复制的长度（字节）为_Size。

int a[5]{1001, 1002, 1003, 1004, 1005};
int *p = new int[5];
memcpy(p, a, 5*sizeof(int));

1.6. memset

设置内存。

void* memset(void* _Dst, int val, size_t _Size);

memset可以将指定内存区域每一个字节的值都设置为val,_Size为要设置的长度（字节）。

int* p = new int[100];
memset(p, 0, 100*sizeof(int)); //相当于将数组P 100个元素都初始化为 0。

• 注意：每个字节都初始化为val，所以val虽然是int类型，但它的取值范围只能是一个字节，即：0 ~ 0xff。

---

3. C++中的动态内存分配

3.1 new

1. 数据类型* 指针变量名称 = new 数据类型；

int* pa = new int;

2. 数据类型* 指针变量名称 = new 数据类型[数量]

int* pa = new int[5]; //分配一段能够存放5个int变量类型的内存空间

• 注意：分配失败，pa返回0.

---

3.2 delete

1. delete 指针。释放用new分配的内存；

int* pa = new int;
delete pa;

2. delete[] 指针。释放用new 数据类型[]分配的内存。

int* p = new int[5];
delete[] p;

4. 练习

需求：

原数组元素有：1，5，10，25， 35，45， 46，57，67，99。现用户随意输入一个数字，要求输出数组正序或倒序排序结果。

• 知识点： 异运算 、memcpy。

	int a[10]{ 1, 5, 10, 25, 35, 45, 46, 57, 67, 99 };
	//int a[10]{ 99, 67, 57, 46, 45, 35, 25, 10, 5, 1 };

	int acount = sizeof(a) / sizeof(int);
	int* anew = new int[acount + 1];

	int x;
	std::cout << "输入新的数据：";
	std::cin >> x;

	int getIndex{ acount };

	/*if (a[0] > a[1]) {
		for (int i = 0; i < acount; i++) {
			if (x > a[i]) {
				getIndex = i;
				break;
			}
		}
	}
	if (a[0] < a[1]){
		for (int i = 0; i < acount; i++) {
			if (x < a[i]){
				getIndex = i;
				break;
			}
		}
	}*/

	//优化
	bool bcase = a[0] > a[1];
	for (int i = 0; i < acount; i++) {
		if (bcase ^ (x < a[i])) {
			getIndex = i;
			break;
		}
	}

	/**
	 memcpy
	 复制内存。
     void* memcpy(void* _Dst, const void* _Src, size_t _Size);
     memcpy可以将_Src区域的内存复制到_Dst区域，复制的长度（字节）为_Size。
	*/

	memcpy(anew, a, getIndex * sizeof(int));

	memcpy(anew + getIndex + 1, a + getIndex, (acount - getIndex) * sizeof(int));

	anew[getIndex] = x;

	for (int i = 0; i <= acount; i++)std::cout << anew[i] << std::endl;