Day7（上）.二级指针实战

首先练习一下二级指针做函数参数的问题，题目在代码最前面。

/*******************************************************************************************************************
	题目：合并并排序两个指针数组，假如char *array1[] = { "bbbbb", "aaaaa", "ccccc", "22222", "11111", "44444" }，  
	char array2[10][30] = { "zzzz", "yyyy", "xxxx" }，合并输出{ "bbbbb", "aaaaa", "ccccc", "22222", "11111", 
	"44444", "zzzz", "yyyy", "xxxx" }，并按照从小到大/从大到小的顺序输出结果。
	思路：	1.定义一个二级指针，用于保存结果
			2.在排序函数体内，将题目中的两个指针数组合并，然后排序
			3.输出结果，释放内存空间
	函数：	char **sortArray1Array2(char **pArray1, int nArray1Num, char(*pArray2)[30], int nArray2Num, int *nArray3Num)
			void free_arr(char ** arr, int length)
	说明：	二级指针做函数参数；二级指针做函数参数把结果甩出来；怎么malloc怎么free
*******************************************************************************************************************/
#define _CRT_SECURE_NO_WARNINGS
#include "stdlib.h"
#include "stdio.h"
#include "string.h"

//合并排序函数
char **sortArray1Array2(char **pArray1, int nArray1Num, char(*pArray2)[30], int nArray2Num, int *nArray3Num)
{
	int i, j;
	//输出结果的长度
	int length = nArray1Num + nArray2Num;
	//malloc输出结果的内存空间
	char **pTmp = (char **)malloc((nArray1Num + nArray2Num)*sizeof(char *));
	//一级指针分配内存
	for (i = 0; i < length; i++)
	{
		pTmp[i] = (char *)malloc(sizeof(char) * 30);
		memset(pTmp[i], 0, sizeof(char) * 30);
	}
	//把第一个指针数组复制到输出指针数组
	for (i = 0; i < nArray1Num; i++)
	{
		strcpy(pTmp[i], pArray1[i]);
	}
	//把第二个指针数组复制到输出指针数组
	for (int k = 0; k < nArray2Num; k++, i++)
	{
		strcpy(pTmp[i], pArray2[k]);
	}
	//排序
	for (i = 0; i < length; i++)
	{
		for (j = 0; j < length; j++)
		{
			if (strcmp(pTmp[i], pTmp[j]) > 0)
			{
				char tmp[30] = { 0 };
				strcpy(tmp, pTmp[i]);
				strcpy(pTmp[i], pTmp[j]);
				strcpy(pTmp[j], tmp);
			}
		}
	}
	//把输出指针数组的长度甩出来
	*nArray3Num = length;
	//返回输出结果指针数组
	return pTmp;
}
void free_arr(char ** arr, int length)
{
	int i;
	//判断形参是否为空
	if (arr == NULL)
	{
		return;
	}
	//释放内存空间，记住一点，怎么malloc怎么free
	for (i = 0; i < length; i++)
	{
		if (arr[i] != NULL)
			free(arr[i]);
	}
	//判断每一个一级指针是否为空，不为空释放
	if (arr[i] != NULL)
	{
		free(arr);
	}
}
void main()
{
	int i;
	//输出指针数组，指针切记要初始化
	char **pArray3 = NULL;
	int nArray3Num = 0;
	//要合并的两个指针数组
	char *array1[] = { "bbbbb", "aaaaa", "ccccc", "22222", "11111", "44444" };
	char array2[10][30] = { "zzzz", "yyyy", "xxxx" };
	//合并排序
	pArray3 = sortArray1Array2(array1, 6, array2, 3, &nArray3Num);
	//判断合并排序是否成功
	if (pArray3 == NULL)
	{
		printf("func sortArray1Array2() err\n");
	}
	//打印输出指针数组
	for (i = 0; i < nArray3Num; i++)
	{
		printf("%s \n", pArray3[i]);
	}
	//释放内存空间
	if (pArray3 != NULL)
	{
		free_arr(pArray3, nArray3Num);
		pArray3 = NULL;
	}

	system("pause");
}

在操作内存空间的时候，时刻要注意内存的分配和释放问题，必须要记住下面的初始化模版，做任何相关内存操作的项目，都必须首先在脑海中建立一个这样的初始化模型

/*******************************************************************************************************************
	题目：合并并排序两个指针数组，假如char *array1[] = { "bbbbb", "aaaaa", "ccccc", "22222", "11111", "44444" }，  
	char array2[10][30] = { "zzzz", "yyyy", "xxxx" }，合并输出{ "bbbbb", "aaaaa", "ccccc", "22222", "11111", 
	"44444", "zzzz", "yyyy", "xxxx" }，并按照从小到大/从大到小的顺序输出结果。
	思路：	1.定义一个二级指针，用于保存结果
				2.在排序函数体内，将题目中的两个指针数组合并，然后排序
				3.输出结果，释放内存空间
	函数：	char **sortArray1Array2(char **pArray1, int nArray1Num, char(*pArray2)[30], int nArray2Num, int *nArray3Num)
				void free_arr(char ** arr, int length)
	说明：	二级指针做函数参数；二级指针做函数参数把结果甩出来；怎么malloc怎么free
*******************************************************************************************************************/
#define _CRT_SECURE_NO_WARNINGS
#include "stdlib.h"
#include "stdio.h"
#include "string.h"

//合并排序函数
char **sortArray1Array2(char **pArray1, int nArray1Num, char(*pArray2)[30], int nArray2Num, int *nArray3Num)
{
	int i, j;
	int length;
	//malloc输出结果的内存空间
	char **pTmp = (char **)malloc((nArray1Num + nArray2Num)*sizeof(char *));
	//一级指针分配内存
	for (i = 0; i < length; i++)
	{
		pTmp[i] = (char *)malloc(sizeof(char) * 30);
		memset(pTmp[i], 0, sizeof(char) * 30);
	}

	/******************************************/

	//返回输出结果指针数组
	return pTmp;
}
void free_arr(char ** arr, int length)
{
	int i;
	//判断形参是否为空
	if (arr == NULL)
	{
		return;
	}
	//释放内存空间，记住一点，怎么malloc怎么free
	for (i = 0; i < length; i++)
	{
		if (arr[i] != NULL)
			free(arr[i]);
	}
	//判断每一个一级指针是否为空，不为空释放
	if (arr[i] != NULL)
	{
		free(arr);
	}
}
void main()
{
	int i;
	//输出指针数组，指针切记要初始化
	char **pArray3 = NULL;
	int nArray3Num = 0;
	//要合并的两个指针数组
	char *array1[] = { "bbbbb", "aaaaa", "ccccc", "22222", "11111", "44444" };
	char array2[10][30] = { "zzzz", "yyyy", "xxxx" };
	//合并排序
	pArray3 = sortArray1Array2(array1, 6, array2, 3, &nArray3Num);
	//判断合并排序是否成功
	if (pArray3 == NULL)
	{
		printf("func sortArray1Array2() err\n");
	}

	/******************************************/

	//释放内存空间
	if (pArray3 != NULL)
	{
		free_arr(pArray3, nArray3Num);
		pArray3 = NULL;
	}

	system("pause");
}

———————————————————————————————————————————————————————————————————————————

下面是本节重点，有关二级指针做输出的问题。在学习完下面的内容之后，必须深刻理解这句话：

二级指针做函数参数（形参），在被调用函数里面修改实参。

如下是一个简单的例子，说明如何用一级指针去修改0级指针的值

#define _CRT_SECURE_NO_WARNINGS
#include "stdlib.h"
#include "stdio.h"
#include "string.h"

//用一级指针（通常是形参），去修改0级指针（通常是实参）的值
int  getlen(int *p)
{
	*p = 20;
}
void main()
{
    int a;
    int *p = NULL;

    p = &a;
    //直接修改a的值
    a = 1;
    //p是a的地址，*(a的地址)去间接修改a的值
    *p = 10;
    //1级指针去修改0级指针的值
    getlen(&a);
    printf("a:%d \n", a);

    system("pause");
}

我们再深入一层，用二级指针去修改一级指针的值

#define _CRT_SECURE_NO_WARNINGS
#include "stdlib.h"
#include "stdio.h"
#include "string.h"

//用二级指针去修改一级指针的值
void main()
{
	char *p = NULL;
	char ** p2 = NULL;
	//直接修改p的值
	p = 0x11;
	printf("p:%x \n", p);

	//此处要理解&p的意义，即p成了和p2一样的“二级指针”
	p2 = &p;
	//*(p2)即为*(&p)=p，为了理解而这样解释
	*(p2) = 0x22;
	printf("p:%x \n", p);

	system("pause");
}

我们用函数体的形式实现上面的代码，在上面的形式上继续修改

#define _CRT_SECURE_NO_WARNINGS
#include "stdlib.h"
#include "stdio.h"
#include "string.h"

//用二级指针（通常是形参），去修改一级指针（通常是实参）的值
int getmembuf(char **p2)
{
	//*(p2)即为*(&p)=p，为了理解而这样解释
	*(p2) = 0x33;
	return 0;
}
void main()
{
	char *p = NULL;
	char ** p2 = NULL;
	//直接修改p的值
	p = 0x11;
	printf("p:%x \n", p);

	//此处要理解&p的意义，即p成了和p2一样的“二级指针”
	p2 = &p;
	//*(p2)即为*(&p)=p，为了理解而这样解释
	*(p2) = 0x22;
	printf("p:%x \n", p);

	getmembuf(&p);
	printf("p:%x \n", p);

	system("pause");
}

但是这样做的意义何在呢？？？为什么要这样用二级指针？？？

下面看继续修改的结果代码，只修改int getmembuf函数体

//用二级指针（通常是形参），去修改一级指针（通常是实参）的值
//相当于在被调用函数体内分配内存，把结果给甩出来
int getmembuf(char **p2)
{
    //1.便于理解
    //函数体内分配内存空间，使用二级指针将其甩出来
    char **tmp;
    tmp = (char *)malloc(100);
    p2 = tmp;
    //2.实际项目这样写
    p2 = (char *)malloc(100);
    
    return 0;
}

必须掌握上面的用法，二级指针做函数参数，函数体内分配内存，用二级指针把结果甩出来！！！！否则，C/C++的指针是白学的！！！！

总之，二级指针做函数参数（形参），在被调用函数里面修改实参。

———————————————————————————————————————————————————————————————————————————

二级指针做输出易犯错误

1.首先看第一个例子

#include "stdlib.h"
#include "stdio.h"
#include "string.h"

int getmembuf(char **p)
{
	char **tmp;
	tmp = (char *)malloc(100);
	*p = tmp;
	return 0;
}
void main()
{
	char **p = NULL;
	getmembuf(p);
	system("pause");
}

上面的例子，一执行就会down掉，为什么呢？？？我们来分析一下它的内存模型

2.show the codes

#include "stdlib.h"
#include "stdio.h"
#include "string.h"


int getmembuf1(char **p)
{
	char **tmp;
	tmp = (char *)malloc(100);
	tmp = "aaaaaaannnnnnnn";
	*p = tmp;
	return 0;
}

void main()
{
	//buf指针是一个const类型，无法修改
	char buf[10];
	//此处buf当作形参是错误的
	getmembuf1(&buf);
	printf("%s", buf);

	if (buf != NULL)
	{
		free(buf);
	}
	system("pause");
}

需要特别注意，二级指针做函数参数的时候，必须能够修改，即必须非const类型，上面代码的char buf[10]是无法修改内存地址的，切记！！！
3.重复提及的二级指针做函数参数，在被调用函数里分配内存，并把结果甩出函数体。

看下面的代码对比

void getmembuf(char *buf)
{
	char * tmp;
	tmp = (char)malloc(100);
	buf = tmp;
	return;
}

void getmembuf(char **buf)
{
	char ** tmp;
	tmp = (char*)malloc(100);
	buf = tmp;
	return;
}

不多说了，不解释，自己看！！！二级指针做函数参数，在被调用函数里分配内存的精髓就是这两段代码！！！

4.结构体中的问题

看第一段代码

#include "stdlib.h"
#include "stdio.h"
#include "string.h"

struct Teacher
{
	char name[10];
	int age;
};

struct Teacher *createTeacher()
{
	struct Teacher *tmp = NULL;
	tmp = (struct Teacher *)malloc(sizeof(struct Teacher));
	return tmp;
}
void main()
{
	struct Teacher *t1 = createTeacher();

	if (t1 != NULL)
	{
		free(t1);
	}
 	system("pause");
}

看第二段代码

#include "stdlib.h"
#include "stdio.h"
#include "string.h"

struct Teacher
{
	char name[10];
	int age;
};

int createTeacher(struct Teacher **p)
{
    //不要相信别人给你传的地址是可用的
    if (p == NULL)
        return -1;
    struct Teacher *tmp = NULL;
    tmp = (struct Teacher *)malloc(sizeof(struct Teacher));
    *p = tmp;
    return 0;
}

void main()
{
	struct Teacher *t = NULL;
	createTeacher(&t);

	if (t != NULL)
	{
		free(t);
	}

 	system("pause");
}

仔细观察如何将struct Teacher *createTeacher()替换成int createTeacher(struct Teacher **p)！！！

还不懂？？？？继续延伸！！！！

#include "stdlib.h"
#include "stdio.h"
#include "string.h"

int getmembuf(char ****p)
{
	*p = 0x4;
}
void main()
{
	char ****p1 = NULL;
	char *****p2 = NULL;
	//直接修改
	p1 = 0x1;
	p1 = 0x2;

	//间接修改
	p2 = &p1;
	*p2 = 0x3;
	printf("%d\n", p1);
	//间接修改2
	getmembuf(&p1);
	printf("%d\n", p1);

	system("pause");
}

一定要明白N级指针修改N-1级指针内存空间的方法！！！！！！