＜C语言＞指针的深度学习

目录

一、字符指针

二、指针数组

三、数组指针

1.数组指针的定义

2.&数组名与数组名

3.数组指针的使用

四、数组参数、指针参数

1.一维数组传参

2.二维数组传参

3.一级指针传参

4.二级指针传参

五、函数指针

六、函数指针数组

七、指向函数指针数组的指针

八、回调函数

1. 回调函数概念

九、指针笔试题

一、字符指针

指针类型中 char * 为字符指针

一般使用：

int main()
{
    char ch = 'w';
    char *pc = &ch;
    *pc = 'w';
    return 0;
}

另一种使用方式：

int main()
{
	const char* ptr = "hello world";//常量字符串不能被修改，所以用const修饰
	printf("%s", ptr);
	return 0;
}

将常量字符串首字符的地址赋值给字符指针ptr，字符串常量的值是代表存放字符串常量首字符的储存单元的地址，实质上是一个指向该字符串首字符的指针常量。

笔试题：

#include <stdio.h>
int main()
{
	char str1[] = "hello world.";
	char str2[] = "hello world.";
	const char* str3 = "hello world.";
	const char* str4 = "hello world.";
	if (str1 == str2)
		printf("str1 and str2 are same\n");
	else
		printf("str1 and str2 are not same\n");

	if (str3 == str4)
		printf("str3 and str4 are same\n");
	else
		printf("str3 and str4 are not same\n");

	return 0;
}

str1 and str2 are not same
str3 and str4 are same

由于常量字符串不能被修改，所以常量字符串只会在内存中存放一份（只读数据区），当赋值定义时共用该常量字符串。而字符数组与之不同，即使内容相同，也不会共用同一内存空间。

二、指针数组

整型数组——存放整形的数组

字符数组——存放字符的数组

指针数组——存放指针的数组

字符指针数组：

#include <stdio.h>
int main()
{
	const char* arr[4] = { "abcdef","qwer","hello world","hehe" };
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%s\n", arr[i]);
	}
	return 0;
}

//打印
abcdef
qwer
hello world
hehe

整形指针数组：

#include <stdio.h>
int main()
{
	int arr1[5] = { 1,2,3,4,5 };
	int arr2[5] = { 2,3,4,5,6 };
	int arr3[5] = { 3,4,5,6,7 };
	int arr4[5] = { 0,0,0,0,0 };

	int* arr[4] = { arr1,arr2,arr3,arr4 };
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
			//printf("%d",*(arr[i]+j));
            // arr[i] == *(arr + i)，与指针数组很像
		}
		printf("\n");
	}
	return 0;
}

三、数组指针

1.数组指针的定义

整形指针——存放整形地址的指针——指向整形的指针——char *

字符指针——存放字符地址的指针——指向字符的指针——int *

数组指针——存放数组地址的指针——指向数组的指针

int main()
{
	char ch = 'w';
	char* pc = &ch;

	int num = 10;
	int* pi = &num;

	int arr[10];

	//pa就是一个数组指针
	int (*pa)[10] = &arr;

	return 0;
}

解释：p先和*结合，说明p是一个指针变量，然后指针指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。（理解）
这里要注意：[ ] 的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

int （*p）[10] = arr;//错误

这样写是错误写法,是不合理的，因为arr数组名代表数组首元素地址，是int*，而此时p的类型是int(*)[10]，两者类型不同

2.&数组名与数组名

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", &arr);
	return 0;
}

可以发现数组首元素的地址和数组的地址从值的角度来看是相同的，但它们所代表的意义不同：

我们知道指针类型不同，指针+1或-1，指针移动的字节数不同，故

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("arr = %p\n", arr);
	printf("&arr= %p\n", &arr);
	//printf("%p\n", &arr[0]);//int*
	//printf("%p\n", &arr[0]+1);//4
	printf("arr+1 = %p\n", arr + 1);
	printf("&arr+1= %p\n", &arr + 1);
	return 0;
}

根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。

实际上： &arr 表示的是数组的地址，而不是数组首元素的地址，&arr 的类型是： int(*)[10] ，是一种数组指针类型，数组地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40

&arr 取出的是数组的地址，只有数组的地址才需要数组指针来接收！

//例如
char arr[5];
char (*pc)[5] = &arr;
// (*pc)代表pc为指针，因为它要接收数组的地址，[5]代表pc指向的是数组，数组有6个元素，每个元素为char

3.数组指针的使用

学习了数组指针，那么数组指针有什么用处，该怎么用呢？

一种鸡肋用法：

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	int(*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
	//但是我们一般很少这样写代码
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", (*p)[i]);
	}
	return 0;
}

//打印
1 2 3 4 5 6 7 8 9 10

p表示数组的地址，它有能力访问所有元素，(*p)表示解引用指针，表示数组首元素的地址，* ( ( *p) + i)表示第几个元素。

一个数组指针的使用：

#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
void print_arr2(int(*arr)[5], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
	print_arr1(arr, 3, 5);
	//数组名arr，表示首元素的地址
	//但是二维数组的首元素是二维数组的第一行
	//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
	//可以数组指针来接收
	print_arr2(arr, 3, 5);
	return 0;
}

二维数组是一维数组的一维数组，二维数组名就是第一行的地址，不是a[0][0]的地址，是数组的地址，类型为 int(*)[ ] 。arr + i 是第i行的地址，*(arr + i) 是第i行第一个元素的地址 *( * ( arr + i ) + j) 就是第 i 行第 j 列的元素。

所以，一个二维数组传参，形参可以是数组指针也可以是二维数组。

在学习了指针数组与数组指针，看下面四个定义，解释定义的类型是什么。

int arr[5];
int* parr1[10];
int(*parr2)[10];
int(*parr3[10])[5];

整型数组，数组是5个元素
指针数组，数组10个元素，每个元素是int *类型
数组指针，指针指向一个数组，数组是10个元素，每个元素是int
数组指针数组，parr3先与 [ ]结合，是数组，数组有十个元素，每个元素是 int( * )[ 5 ]

四、数组参数、指针参数

1.一维数组传参

#include <stdio.h>
void test(int arr[])//ok?    OK    可以不指定数组大小
{}
void test(int arr[10])//ok?    OK
{}
void test(int* arr)//ok?    OK
{}
void test2(int* arr[20])//ok?    OK
{}
void test2(int** arr)//ok?    OK
{}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);//指针数组名，二级指针
}

2.二维数组传参

void test(int arr[3][5])//ok？    OK
{}
void test(int arr[][])//ok？    NO
{}
void test(int arr[][5])//ok？    OK
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int *arr)//ok？    NO
{}    
void test(int* arr[5])//ok？    NO
{}
void test(int (*arr)[5])//ok？    OK
{}
void test(int **arr)//ok？    NO
{}
int main()
{
 int arr[3][5] = {0};
 test(arr);
}

总结：二维数组传参，函数形参的设计只能省略第一个[ ]的数字，因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素，这样才方便运算。

分析传过来的是什么，就可判断。

3.一级指针传参

#include <stdio.h>
void print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", *(p + i));
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//一级指针p，传给函数
	print(p, sz);
	return 0;
}

思考：

当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

一维数组数组名
一级指针

4.二级指针传参

#include <stdio.h>
void test(int** ptr)
{
	printf("num = %d\n", **ptr);
}
int main()
{
	int n = 10;
	int* p = &n;
	int** pp = &p;
	test(pp);
	test(&p);
	return 0;
}

思考：

当函数的参数为二级指针的时候，可以接收什么参数？

二级指针
一级指针的地址
指针数组名

void test(char** p)
{

}
int main()
{
	char c = 'b';
	char* pc = &c;
	char** ppc = &pc;
	char* arr[10];
	test(&pc);
	test(ppc);
	test(arr);//Ok?
	return 0;
}

五、函数指针

#include <stdio.h>
void test()
{
	printf("hehe\n");
}
int main()
{
	printf("%p\n", test);
	printf("%p\n", &test);
	return 0;
}

输出的是两个地址，这两个地址是 test 函数的地址。&函数名与函数名都是函数的地址.

那我们的函数的地址要想保存起来，怎么保存？

下面我们看代码：

int add(int x, int y)
{
    return x +y ;
}

void test()
{
    printf("hehe\n");
}

int (*pf)(int, int) = &add;

下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();

首先，能给存储地址，就要求pfun1或者pfun2是指针，那哪个是指针？

答案是：

pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。

使用（）将pf先于*结合，表示指针，再写指针指向函数的参数类型，返回值类型。
使用指针访问函数时，还是（）将pf与*结合，又此时是函数，函数需要传参，再用（）传参。

其实在调用函数指针时，pf 前面可以不写*，因为定义函数指针后，pf相当于add函数的别名，函数名可以直接使用，那么函数指针也是可以直接使用的，简单地说，前面的*是没有用的，即使是n个*也还是正常使用，但是如果非要使用（*pf）形式的话，必须加（）保证优先级，如果*pf不是用括号，那么由于优先级顺序，会造成一些问题。

int (* pf)(int, int) = add;

int ret = pf(2, 3);
int ret = (*pf)(2, 3);

结果都是5,两式等价

下面，我们来阅读两段有趣的代码：

//代码1
(*(void (*)())0)();
//代码2
void (*signal(int, void(*)(int)))(int);

改代码是调用0地址处的函数，是一次函数调用，首先 ( void (*) () ) 0将整型0强转为函数指针类型 void (*)()，再调用0地址处函数
该代码是一次函数的声明，声明的函数名字叫 signal，函数 signal 的参数有两个，第一个是int类型参数，第二个是函数指针类型参数，并且该函数指针能指向的那个函数返回类型是void，函数参数是int类型，而signal函数的返回类型是一个函数指针，可以理解为

void (*)(int) signal(int, void (*)(int));

但是在语法上，该代码是错误的，它只是有助于我们理解

代码2太复杂，如何简化：

我们知道，typedef可以简化重命名，但是要注意：

typedef void(*)(int) pf_t;

上面这个重命名形式在语法上是错误的，重命名的名字应放在括号里。 （其他重命名规则依旧，这里特殊）

typedef void(*pf_t)(int);

pf_t signal(int, pfun_t);

例题：

定义一个函数指针，指向的函数有两个int形参并且返回一个函数指针，返回的指针指向一个有一个int形参且返回int的函数。

类比上面第二题，要注意，第二题是函数声明，而该例题是定义函数指针

int (*(*f)(int, int))(int);

六、函数指针数组

我们知道，整型指针是指向整型的指针，数组指针是指向数组的指针，其实，函数指针就是指向函数的指针。和学习数组指针一样，学习函数指针我们也需要知道三点：

( )的优先级要高于 * 。
一个变量除去了变量名，便是它的变量类型。
一个指针变量除去了变量名和 * ，便是指针指向的内容的类型。

数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组，

比如：

int *arr[10];
//数组的每个元素是int*

那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];

答案是：parr1

parr1 先和 [] 结合，说明 parr1是数组，数组的内容是什么呢？

是 int (*)() 类型的函数指针。

函数指针数组的用途：转移表

例子：（计算器）

#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	do
	{
		printf("*************************\n");
		printf(" 1:add           2:sub \n");
		printf(" 3:mul           4:div \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = add(x, y);
			printf("ret = %d\n", ret);
			break;
		case 2:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = sub(x, y);
			printf("ret = %d\n", ret);
			break;
		case 3:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = mul(x, y);
			printf("ret = %d\n", ret);
			break;
		case 4:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = div(x, y);
			printf("ret = %d\n", ret);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

	return 0;
}

使用函数指针数组的实现：

#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
	while (input)
	{
		printf("*************************\n");
		printf(" 1:add           2:sub \n");
		printf(" 3:mul           4:div \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		if ((input <= 4 && input >= 1))
		{
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = (*p[input])(x, y);
		}
		else
			printf("输入有误\n");
		printf("ret = %d\n", ret);
	}
	return 0;
}

七、指向函数指针数组的指针

指向函数指针数组的指针是一个指针，指针指向一个数组，数组的元素都是函数指针 ;

如何定义？

既然存在函数指针数组，那么必然存在指向函数指针数组的指针。

	int(*p)(int, int);
	//函数指针
	int(*pArr[5])(int, int);
	//函数指针数组
	int(*(*pa)[5])(int, int) = &pArr;
	//指向函数指针数组的指针

void test(const char* str)
{
 printf("%s\n", str);
}
int main()
{
 //函数指针pfun
 void (*pfun)(const char*) = test;
 //函数指针的数组pfunArr
 void (*pfunArr[5])(const char* str);
 pfunArr[0] = test;
 //指向函数指针数组pfunArr的指针ppfunArr
 void (*(*ppfunArr)[5])(const char*) = &pfunArr;
 return 0;
}

八、回调函数

1. 回调函数概念

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

首先演示一下qsort函数的使用：

#include <stdio.h>
//qosrt函数的使用者得实现一个比较函数
int int_cmp(const void * p1, const void * p2)
{
  return (*( int *)p1 - *(int *) p2);
}
int main()
{
    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    int i = 0;
    
    qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
    for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
   {
       printf( "%d ", arr[i]);
   }
    printf("\n");
    return 0;
}

使用回调函数，模拟实现qsort（采用冒泡的方式）

#include <stdio.h>
int int_cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}
void _swap(void* p1, void* p2, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *((char*)p1 + i);
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = tmp;
	}
}
void bubble(void* base, int count, int size, int(*cmp)(void*, void*))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < count - 1; i++)
	{
		for (j = 0; j < count - i - 1; j++)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				_swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	//char *arr[] = {"aaaa","dddd","cccc","bbbb"};
	int i = 0;
	bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

九、指针笔试题

笔试题 1 ：

int main()
{
    int a[5] = { 1, 2, 3, 4, 5 };
    int *ptr = (int *)(&a + 1);
    printf( "%d,%d", *(a + 1), *(ptr - 1));
    return 0;
}
//程序的结果是什么？

笔试题 2

//由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{
 int Num;
 char *pcName;
 short sDate;
 char cha[2];
 short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
 printf("%p\n", p + 0x1);
 printf("%p\n", (unsigned long)p + 0x1);
 printf("%p\n", (unsigned int*)p + 0x1);
 return 0;
}

笔试题 3

int main()
{
    int a[4] = { 1, 2, 3, 4 };
    int *ptr1 = (int *)(&a + 1);
    int *ptr2 = (int *)((int)a + 1);
    printf( "%x,%x", ptr1[-1], *ptr2);
    return 0;
}

笔试题 4

#include <stdio.h>
int main()
{
    int a[3][2] = { (0, 1), (2, 3), (4, 5) };
    int *p;
    p = a[0];
    printf( "%d", p[0]);
 return 0;
}

笔试题 5

int main()
{
    int a[5][5];
    int(*p)[4];
    p = a;
    printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    return 0;
}

笔试题 6

int main()
{
    int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int *ptr1 = (int *)(&aa + 1);
    int *ptr2 = (int *)(*(aa + 1));
    printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
    return 0;
}

笔试题 7

#include <stdio.h>
int main()
{
 char *a[] = {"work","at","alibaba"};
 char**pa = a;
 pa++;
 printf("%s\n", *pa);
 return 0;
}

注意：我们知道char** pa = a; 这里后一个*表示pa是指针，第一个*与char结合，表示pa指针指向的对象是char*类型，例如

int *p;
p+1;

p++是跳过前面的一个char类型，同理char** pa，pa++这里跳过一个char*类型

笔试题 8

int main()
{
 char *c[] = {"ENTER","NEW","POINT","FIRST"};
 char**cp[] = {c+3,c+2,c+1,c};
 char***cpp = cp;
 printf("%s\n", **++cpp);
 printf("%s\n", *--*++cpp+3);
 printf("%s\n", *cpp[-2]+3);
 printf("%s\n", cpp[-1][-1]+1);
 return 0;
}

关键是画图理解