C语言——动态内存管理与内存操作函数

星辰与你

发布于 2024-10-17 19:33:04

650

发布于 2024-10-17 19:33:04

文章被收录于专栏：学习

一、内存分配

在学习之前，首先要知道计算机内存是如何分配的：

内存可以大致分五个区，这里先学习栈区，堆区和静态区

1.静态存储区分配

静态区中存储的主要是全局变量和static修饰的变量；

主要是系统用于自动分配给全局变量、static修饰的变量内存的。它们在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。

2.在堆区分配

堆区中存储的主要是函数的形参，局部变量；

主要是用于系统自动分配给函数内部的局部变量的，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放.栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。

3.在栈区上分配，也称动态内存分配

代码程序在运行时，使用malloc（内存申请函数）所开辟的空间，就是在栈区上开辟的，这部分内存可以又程序员自由支配，当然释放所申请的内存也是又程序员自己负责free；这种方式使用起来比较方便，问题也比较多。

二、为什么要有动态内存分配？

学到现在，我们去申请一块空间，就是直接定义一个变量或者数组去开辟空间

int a = 20;//在栈区上开辟4个字节的空间
int arr[10] = { 0 };//在栈区上开辟40个字节的连续空间

但时这样去开辟的空间

空间开辟大小都是固定的
在申请一个数组时，需要提前声明数组的长度，数组的大小确定后就无法被修改

但是，有时我们在程序运行时才能知道所需空间的大小，这样的话，就无法正确的去申请空间了（这里，如果一开始申请足够大的空间，可能导致空间浪费）。

C语言中引入了动态内存开辟，这样写代码过程中就可以自己去申请和释放空间，使用起来就比较灵活了。

三、动态内存分配函数

<1>动态内存开辟函数

C语言提供了动态内存开辟函数 malloc 和 calloc

1.malloc函数

void* malloc (size_t size);

malloc这个函数向内存申请一块连续可用的函数，并返回指向这块内存空间的指针；

如果开辟内存成功，则返回指向开辟好的空间的指针
如果开辟内存失败，则返回NULL(空)指针，所以在使用malloc返回值之前要先检查
malloc函数返回类型是void*，在使用malloc开辟的内存时，要自己决定类型
如果参数size为0，即malloc(0); 这种有些编译器会报错，尽量不要这样写代码

#include<stdio.h>
#include<stdlib.h>
int main() {
	int* p = (int*)malloc(20); //开辟空间
	if (p == NULL) { //判断开辟是否成功
		perror("malloc");
		return 1;
	}
	//使用内存
	int i = 0;
	for (i = 0; i < 5; i++) {
		*(p + i) = i + 1;
		printf("%d\n", *(p + i));
	}
    printf("%x\n", p);
	free(p);//内存释放
    p=NULL;
	return 0;
}

注意：在使用完开辟的内存后，一定要释放，并将指向那块内存的指针置为空指针。

2.calloc函数

 void* calloc (size_t num, size_t size);

calloc函数能给num个大小为size的元素开辟空间，并把每个字节初始化为零
与malloc函数的区别：calloc在开辟内存后会把之申请的空间的每一个字节初始化为0

写代码来看一下calloc与malloc的区别：

malloc

int main() {
	int* p = (int*)malloc(20); //开辟空间
	if (p == NULL) { //判断开辟是否成功
		perror("malloc");
		return 1;
	}
	//使用内存
	int i = 0;
	for (i = 0; i < 5; i++) {
		printf("%d\n", *(p + i)); //直接输出值
	}
	free(p);//内存释放
	return 0;
}

calloc

int main() {
	int* p = (int*)calloc(5,4); //开辟空间
	if (p == NULL) { //判断开辟是否成功
		perror("malloc");
		return 1;
	}
	//使用内存
	int i = 0;
	for (i = 0; i < 5; i++) {
		printf("%d\n", *(p + i));
	}
	free(p);//内存释放
	return 0;
}

通过实践，就能看到calloc与malloc函数的区别

<2>动态内存调整函数

在使用malloc和calloc的时候，我们会发现，有时开辟的内存空间小了，有时开辟的内存空间过大了，为了合理使用所开辟的空间，我们就应该对开辟空间有所调整，C语言中 realloc 就可以做到动态内存空间大小的调整。

realloc函数

realloc的出现让动态内存管理和使用更加灵活

void* realloc (void* ptr, size_t size);

函数中，

ptr是指向需要调整的空间内存的指针
size是调整之后的大小
函数返回值是调整之后的内存起始位置
调整空间失败会返回NULL
在成功调整空间时，realloc存在两种情况：

1.原来空间之后有足够的空间

2.原来空间之后没有足够的空间

情况1：

空间足够，realloc直接在原有内存之和追加空间，原来空间的数据不发生变化

int main() {
	int* p = (int*)malloc(20);
	if (p != NULL) {
		printf("%x\n", p);
		int* ret = realloc(p, 40);
		if (ret != NULL) {
			p = ret;
			ret = NULL;
		}
	}
	printf("%x\n", p);
    free(p);
    p=NULL;
	return 0;
}

情况2：

原空间后没有足够多的空间，realloc函数会在堆区空间上另找应该合适大小的连续空间，并将数据拷贝过去；这样的话，函数返回的是新的内存的地址。

int main() {
	int* p = (int*)malloc(20);
	if (p != NULL) {
		printf("%x\n", p);
		int* ret = realloc(p,1000);
		if (ret != NULL) {
			p = ret;
			ret = NULL;
		}
	}
	printf("%x\n", p);
	return 0;
}

<3>动态内存释放函数

在动态内存开辟并使用完以后，要进行释放，还给操作系统（如果没有主动释放，在程序结束后会自动释放，但是还是要主动进行释放，防止出现内存泄漏等问题）

free函数

 void free (void* ptr);

free函数是专门用来对动态内存进行释放的。

如果free的参数是NULL指针，则函数什么都不做；

如果free参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。

注意：free函数在释放空间后，并不会把ptr指针置为空指针，这里需要手动将其置为空

<3>常见的动态内存使用错误

1.对NULL指针进行解引用

void test()
 {
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;//如果p的值是NULL，就会有问题
 free(p);
 }

在接收malloc或者calloc开辟空间返回值后，要先进行判断释放为空指针，即判断开辟是否成功。

2.对动态开辟空间的越界访问

void test()
 {
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 exit(EXIT_FAILURE);
 }
 for(i=0; i<=10; i++)
 {
 *(p+i) = i;//当i是10的时候越界访问
 }
 free(p);
 }

3.对非动态开辟内存使用free释放

int main 
{
    int a = 10;
    int *p = &a;
    free(p);//ok?
    return 0;
}

尽量避免这种写法

4.使用free释放一块开辟内存的一部分

void test()
 {
    int *p = (int *)malloc(100);
    p++;
    free(p);//p不再指向动态内存的起始位置
 }

free在释放空间内存时，一定是把动态开辟空间的起始地址传给free

5.对同一块动态内存多次释放

void test()
 {
    int *p = (int *)malloc(100);
    free(p);
    free(p);//重复释放
 }

这种有的编译器会报错，在写代码时不要这样去写

6.动态开辟内存忘记释放（内存泄漏）

void test()
 {
     int *p = (int *)malloc(100);
     if(NULL != p)
     {
     *p = 20;
     }
 }
int main()
{
     test();
     while(1);
 }

像以上代码，没有对动态开辟内存进行释放，只能在程序结束时自动释放，但是函数test一直申请动态空间，这样就会导致栈溢出。

这种情况，忘记对动态开辟的内存进行释放，然后在代码运行的过程中又找不到当初开辟的那快内存，这就会导致内存泄漏。

四、内存操作函数

C语言中既有对字符串进行操作的函数，也有对内存函数，接下来，学习几个C语言内存库函数

我们知道strcpy是对字符串进行拷贝，只能完成拷贝字符串，而内存函数中memcpy就是对内存中存储的数据进行拷贝，不在乎拷贝的是什么类型，这种内存函数就比较倾向与泛型编程，可以对任意类型的数据进行操作。

<1>memcpy使用和模拟实现

函数类型：

1 void * memcpy ( void * destination, const void * source, size_t num );

memcpy函数从source的位置开始向后复制num个字节的数据到destination指向的内存位置
memcpy函数在遇到'\0'时不会停下来

1> memcpy函数使用

#include <stdio.h>
#include <string.h>
int main()
{
     int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
     int arr2[10] = { 0 };
     memcpy(arr2, arr1, 20);
     int i = 0;
     for (i = 0; i < 10; i++)
     {
     printf("%d ", arr2[i]);
     }
     return 0;
}

memcpy函数主要用于空间内存不重叠的数据拷贝，对于内存存在重复部分的数据拷贝，就使用memmove函数

2> memcpy函数模拟实现

void * memcpy ( void * dst, const void * src, size_t count)
{
     void * ret = dst;
     assert(dst);
     assert(src);
     while (count--) {
     *(char *)dst = *(char *)src;
     dst = (char *)dst + 1;
     src = (char *)src + 1;
     }
     return(ret);
}

这里做一个知识补充：强制类型转换是暂时的，这里就不能写成（(char*)dst++)

<2>memmove使用和模拟实现

函数类型

void * memmove ( void * destination, const void * source, size_t num)

memmove和memcpy函数的差别就是mommove函数处理的原内存与目标内存是可以重复的

1> memmov函数使用

#include <stdio.h>
#include <string.h>
int main()
{
    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
     memmove(arr1+2, arr1, 20);
     int i = 0;
     for (i = 0; i < 10; i++)
     {
     printf("%d ", arr1[i]);
     }
     return 0;
}

2> memmove函数模拟实现

对于memmove的模拟，memmove可以对存在重复内存空间的数据进行拷贝，自己去学就会遇到一些问题，在这里简单理一下思路；

可以大致分为两种情况：

1. src > dst

这种情况,就可以按照上面memcpy那种从前往后一个一个进行拷贝. 2. src < dst

这样情况,如果还是按照从前往后一个一个拷贝,就会发现将1拷贝给3的位置就会把3这个数据弄丢;

这中情况,就从后往前进行拷贝,就不会丢失数据了.

代码实现

#include <stdio.h>
#include <string.h>
void* my_memmove(void* dst, const void* src, size_t count)
{
	void* ret = dst;
	if (dst <= src ) {  //前-->后
		while (count--) {
			*(char*)dst = *(char*)src;
			dst = (char*)dst + 1;
			src = (char*)src + 1;
		}
	}
	else {        //后-->前
		dst = (char*)dst + count - 1;
		src = (char*)src + count - 1;
		while (count--) {
			*(char*)dst = *(char*)src;
			dst = (char*)dst - 1;
			src = (char*)src - 1;
		}
	}
	return ret;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr1 + 2, arr1, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

<3>memset使用和模拟实现

void * memset ( void * ptr, int value, size_t num );

memset函数是设置内存的,将内存中的值以字节为单位设置成想要的内容

1> memset函数使用

#include <stdio.h>
#include <string.h>
int main ()
{
     char str[] = "hello world";
     memset (str,'x',6);
     printf(str);
     return 0;
}

2> memset函数模拟实现

void* my_memset(void* ptr, int value, size_t num) {
	void* ret = ptr;
	while (num--) {
		*(char*)ptr = value;
		ptr = (char*)ptr + 1;
	}
}
int main()
{
	char str[] = "hello world";
	void* ret = my_memset(str, 'x', 6);
	printf(str);
	return 0;
}

<4>memcmp使用

 int memcmp ( const void * ptr1, const void * ptr2, size_t num );

memcmp函数从ptr1和ptr2指向的位置开始,向后比较num个字节

#include <stdio.h>
#include <string.h>
int main()
{
     char buffer1[] = "DWgaOtP12df0";
     char buffer2[] = "DWGAOTP12DF0";
     int n;
     n = memcmp(buffer1, buffer2, sizeof(buffer1));
     if (n > 0) 
         printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
     else if (n < 0) 
         printf("'%s' is less than '%s'.\n", buffer1, buffer2);
     else
     printf("'%s' is the same as '%s'.\n", buffer1, buffer2);
     return 0;
}