C语言从入门到精通 第九章（指针与动态内存分配）【下】

  写在前面：

1. 本系列专栏主要介绍C语言的相关知识，思路以下面的参考链接教程为主，大部分笔记也出自该教程。
2. 除了参考下面的链接教程以外，笔者还参考了其它的一些C语言教材，笔者认为重要的部分大多都会用粗体标注（未被标注出的部分可能全是重点，可根据相关部分的示例代码量和注释量判断，或者根据实际经验判断）。
3. 如有错漏欢迎指出。

参考教程：C语言程序设计从入门到进阶【比特鹏哥c语言2024完整版视频教程】（c语言基础入门c语言软件安装C语言指针c语言考研C语言专升本C语言期末计算机二级C语言c语言_哔哩哔哩_bilibili

三、动态内存管理

1、动态内存分配概述

（1）在定义变量或数组时，需要为它们分配相应的空间，只要有确切的声明类型，那么它们得到的空间是固定的，比如字符型变量一定会分配到1个字节的空间（数组在声明的时候必须指定数组的长度，它所需要的内存在编译时分配）。

（2）但是对于空间的需求，不仅仅是上述的情况，有时候需要的空间大小在程序运行的时候才能知道，那么数组在编译时开辟空间的方式就不能满足了，比如定义了一个含100个元素的数组，但是程序在运行过程中需要这个数组有114个元素的空间，为了解决这个问题，只能尝试动态存开辟。

2、动态内存函数的介绍（一）

（1）C语言提供了一个动态内存开辟的函数：

        void* malloc (size_t size);

①这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。如果开辟成功，则返回一个指向开辟好空间的指针；如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。

②malloc的返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。

③如果malloc的参数size为0，则malloc的行为是标准是未定义的，这取决于编译器。

（2）C语言提供了另外一个函数free专门用来做动态内存的释放和回收，函数原型如下：

        void free (void* ptr);

        free函数用来释放动态开辟的内存，如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的；如果参数ptr是NULL指针，则函数什么事都不做。

（3）malloc函数和free函数的声明都在stdlib.h这个头文件中。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>

int main()
{
	int* p = (int*)malloc(40);  //在堆区开辟40字节的内存（返回的指针强制转换为整型指针）
	//如果空间不足，可能会开辟失败，返回空指针
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;  //指针为空，马上终止程序并返回非正常结果
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//没有free并不代表不释放内存空间，程序退出时系统会自动回收内存空间
	free(p);
	p = NULL;  //防止野指针

	return 0;
}

3、动态内存函数的介绍（二）

（1）C语言还提供了一个函数叫calloc，calloc函数也用来动态内存分配，原型如下：

        void* calloc (size_t num, size_t size);

        calloc函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0，与函数malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>

int main()
{
	int* p = (int*)calloc(10, sizeof(int));  //在堆区开辟40字节的内存（返回的指针强制转换为整型指针）
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;  //指针为空，马上终止程序并返回非正常结果
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);   //内存空间使用完毕后需释放，以免“占着不用”
	p = NULL;  //防止野指针

	return 0;
}

（2）realloc函数的出现让动态内存管理更加灵活，有时会发现之前申请的空间太小了，有时候又会觉得之前申请的空间过大了，而realloc函数就可以做到对动态开辟内存大小的调整，以充分利用内存空间。realloc函数原型如下：

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

①ptr是要调整的内存地址；size是调整之后的新大小；返回值为调整之后的内存起始位置。

②这个函数在调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。（旧空间不需要手动释放）

③realloc在调整内存空间的时存在两种情况：

[1]情况1：原有空间之后有足够大的空间，直接原有内存之后直接追加空间，原来空间的数据不发生变化。

[2]情况2：原有空间之后没有足够大的空间，这时要在堆空间上另找一个合适大小的连续空间来使用，这样函数返回的是一个新的内存地址。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>

int main()
{
	int* p = (int*)calloc(10, sizeof(int));  //在堆区开辟40字节的内存（返回的指针强制转换为整型指针）
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;  //指针为空，马上终止程序并返回非正常结果
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	int* ptr = (int*)realloc(p, 80);   //不要用原来的指针接收realloc的返回值
	if (ptr != NULL)
	{
		p = ptr;
	}
	free(p);   //内存空间使用完毕后需释放，以免“占着不用”
	p = NULL;  //防止野指针
	ptr = NULL;

	return 0;
}

4、常见的动态内存操作错误

（1）对NULL指针的解引用。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

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

int main()
{
	
	return 0;
}

（2）对动态开辟空间的越界访问。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

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);
}

int main()
{
	
	return 0;
}

（3）对非动态开辟内存使用free函数释放。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

void test()
{
	int a = 10;
	int *p = &a;
	//free(p);//万万不可！
}

int main()
{
	
	return 0;
}

（4）使用free函数释放一块动态内存的一部分（比如开辟20字节，但仅释放10字节）。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

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

int main()
{
	
	return 0;
}

（5）对同一块动态内存多次释放。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

void test()
{
	int *p = (int *)malloc(100);
	free(p);
	//free(p); //重复释放（建议每次释放后指针置为空指针）
}

int main()
{
	
	return 0;
}

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

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

void test()
{
	int *p = (int *)malloc(100);
	if (NULL != p)
	{
		*p = 20;
	}
}
int main()
{
	test();   //子函数执行结束后，子函数开辟的内存未释放，但是又没办法继续使用（指针p被释放）
	while (true);
}

5、C/C++程序的内存开辟

（1）C/C++程序内存分配的几个区域：

①栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。

②堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。

③数据段（静态区）（static）：存放全局变量、静态数据。程序结束后由系统释放。

④代码段：存放函数体（类成员函数和全局函数）的二进制代码。

（2）实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁，但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁，所以生命周期变长。

四、几个字符串函数及内存函数

1、strstr函数

（1）函数原型：

        char * strstr ( const char *str1, const char * str2);

（2）函数作用：返回一个指向str2在str1中第一次出现的指针，如果str2不是str1的一部分，则返回一个空指针。（该函数用于查找子串）

（3）举例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <assert.h>

char* my_strstr(const char* str1, const char* str2)  //strstr模拟实现
{
	assert(str1 && str2);  //如果传进来的有空指针将不能继续正常运行
	while (*(str1))
	{
		const char* flag1 = str1;
		const char* flag2 = str2;
		if (*str1 == *str2)
		{
			while ((*(flag1) == *(flag2)) && ((*flag2 && *flag1)!= 0))
			{
				flag1++;
				flag2++;
				if (*flag2 == '\0')
					return (char*)str1;
			}
		}
		str1++;
	}
	return NULL;
}

int main()
{
	char str[] = "This is a simple string";
	char * pch;
	pch = strstr(str, "simple");
	if(pch != NULL)
		strncpy(pch, "sample", 6);
	
	printf("%s\n", str);  //This is a sample string
	return 0;
}

2、strtok函数

（1）函数原型：

        char * strtok ( char * str, const char * sep );

（2）函数作用：将一个字符串分割成若干子串。

①sep参数是个字符串，定义了用作分隔符的字符集合。

②第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

③strtok函数找到str中的下一个标记，并将其用’\0’结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可被修改）

④strtok函数的第一个参数不为NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置；strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。

⑤如果字符串中不存在更多的标记，则返回NULL指针。

（3）举例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>

int main()
{
	const char *p = "zhangpengwei@bitedu.tech";
	const char* sep = ".@";
	char arr[30];
	char *str = NULL;
	strcpy(arr, p);//将字符串p中的数据拷贝一份到arr中，处理arr的内容
	for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))  //分割不是一次完成的，需要多次分割，直到无法分割为止
	{
		printf("%s\n", str);
	}
}

3、strerror函数

（1）函数原型：

        char * strerror ( int errnum );

（2）函数作用：返回错误码所对应的错误信息。

（3）举例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <errno.h>

int main()
{
	FILE * pFile;
	pFile = fopen("unexist.ent", "r");
	if (pFile == NULL)
		printf("Error opening file unexist.ent: %s\n", strerror(errno));
	//errno: Last error number
	return 0;
}

4、memcpy函数

（1）函数原型：

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

（2）函数作用：从source的位置开始向后复制num个字节的数据到destination的内存位置，这个函数在遇到'\0'的时候并不会停下来；如果source和destination有任何的重叠，复制的结果都是未定义的。（内存拷贝函数）

（3）举例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <assert.h>

void* my_memcpy(void* dest, const void* src, size_t num)  //memcpy，模拟实现
{
	assert(dest && src);
	void* ret = dest;
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

struct 
{
	char name[40];
	int age;
} person, person_copy;
int main()
{
	char myname[] = "Pierre de Fermat";
    /*拷贝字符串*/
	memcpy(person.name, myname, strlen(myname) + 1);
	person.age = 46;
    /*拷贝结构体 */
	memcpy(&person_copy, &person, sizeof(person));
	printf("person_copy: %s, %d \n", person_copy.name, person_copy.age);
	return 0;
}

5、memmove函数

（1）函数原型：

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

（2）函数作用：该函数和memcpy函数的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的，如果源空间和目标空间出现重叠，就得使用memmove函数处理。

（3）举例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <assert.h>

void* my_memmove(void* dest, const void* src, size_t num)  //memmove，模拟实现
{
	assert(dest && src);
	void* ret = dest;
	if (dest <= src)
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	if (dest > src)
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	
	return ret;
}

struct 
{
	char name[40];
	int age;
} person, person_copy;
int main()
{
	char myname[] = "Pierre de Fermat";
    /*拷贝字符串*/
	memmove(person.name, myname, strlen(myname) + 1);
	person.age = 46;
    /*拷贝结构体 */
	memmove(&person_copy, &person, sizeof(person));
	printf("person_copy: %s, %d \n", person_copy.name, person_copy.age);
	return 0;
}

6、memcmp函数

（1）函数原型：

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

（2）函数作用：比较从ptr1和ptr2指针开始的num个字节，返回值如下。

①在两个内存块中不匹配的第一个字节在ptr1中的值比在ptr2中的值低（如果计算为无符号字符值），返回值小于0。

②两个内存块的内容是相等的，返回值等于0。

③在两个内存块中不匹配的第一个字节在ptr1中的值大于ptr2中的值（如果计算为无符号字符值），返回值大于0。

（3）举例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <assert.h>

int my_memcmp(const void* p1, const void* p2, size_t num)  //memcmp，模拟实现
{
	assert(p1 && p2);
	
	while (num--)
	{
		if (*(char*)p1 != *(char*)p2)
		{
			return (int)*(char*)p1 - (int)*(char*)p2;
		}
		p1 = (char*)p1 + 1;
		p2 = (char*)p2 + 1;
	}

	return 0;
}

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,3,2,4 };
	int ret = memcmp(arr1, arr2, 12);
	printf("%d\n", ret);

	return 0;
}