* 指针进阶 *

字符指针：指向字符的指针，存放的是字符变量的地址

    char *p = "abcdef"

    printf %c 是输出字母a，因为存储的是字符串首字符的地址。

    printf %s 是输出整个字符串

“abcdef”是常量字符串，不能修改（*p = ‘w’）//err，

数组指针： 是指向数组的指针。

数组指针类型 int (*)[10]                    一个指针存一个地址

int* p1 [10]        p1与[]结合，是数组，存放指针的数组

int (*p2)[10]       p2与*结合，是指针，指向数组，指向的数组是十个元素，每个元素的类型是int

int(*parr3[10])[5]  parr3是个数组，数组有10个元素，每个元素的类型是int（*）[5]。Parr3是存放数组指针的数组

如何定义指针变量

eg： char* arr[5]

         char* (*p)[5] = &arr

分析：首先p要存数组的地址，它要是个指针，所以先  （*p），接着要让这个指针指向这个数组，故变为（*p）[5]  。指向的该数组每个元素的类型是char *，所以最终为char* （*p）[5]

把数组名字（和[]）去掉就是数组元素的类型

数组名理解：

通常情况下数组名说的是数组首元素的地址，但有两个例外：

1.sizeof（数组名）

2.&数组名   （详细见初始数组那篇博客）

数组指针应用：

void print1(int (*p)[10], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		//*p 相当于数组名，数组名又是首元素的地址，所以*p就是&arr[0]
		printf("%d ", *(*p + i));
	}
	printf("\n");
}


int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//写一个函数打印arr数组的内容
	int sz = sizeof(arr) / sizeof(arr[0]);
	//
	print1(&arr, sz);

	return 0;
}

这里强行使用数组指针接受参数，不如之前利用指针直接接受来的方便，所以不推荐这种写法。所以数组指针一般不用于一维数组里。

下面使用二维数组来演示数组指针   普通二维数组传参

void print2(int arr[3][5], int c, int r)
{
	int i = 0;
	for (i = 0; i < c; i++)
	{
		int j = 0;
		for (j = 0; j < r; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

void print2(int arr[3][5], int c, int r)
{
	int i = 0;
	for (i = 0; i < c; i++)
	{
		int j = 0;
		for (j = 0; j < r; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

下面是用数组指针传参

void print2(int(*p)[5], int c, int r)
{
	int i = 0;
	for (i = 0; i < c; i++)
	{
		int j = 0;
		for (j = 0; j < r; j++)
		{
			//p+i是指向第i行的
			//*(p+i)相当于拿到了第i行，也相当于第i行的数组名
			//数组名表示首元素的地址，*(p+i) 就是第i行第一个元素的地址
			printf("%d ", *(*(p + i) + j));
			//printf("%d ", p[i][j]);
		}
		//arr[i]
		//*(arr+i)
		// 
		//arr[i][j]
		//*(arr+i)[j]
		//*(*(arr+i)+j)

		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	//int (*ptr)[3][5] = &arr;
	//写一个函数，打印arr数组
	print2(arr, 3, 5);
	return 0;
}

二维数组数组名表示的是第一行的地址，即5个整型的一维数组，因为数组本身是连续存放的，p+1 直接跳过一行数组来到第二行，将二维数组降维传变为一维数组（一行一行接收）

数组下标访问：

arr [i]   <——> *(arr+i)                                等价

arr [i]  [j]         * (arr+i) [j]       *(*(arr+i)+j)    等价

上图为存放数组指针的存储方式 

数组传参

一维数组传参，当形参写成数组的形式时，形参部分数组大小可以省略   void test(int arr[]) (数组名传参的时候，传过去的是数组首元素地址，形参没有创建数组)        当形参写成指针的形式时    void test(int *p)

下面我们进行一个反推，已知形参用整型一级指针来接收，我们思考一下实参可以写什么？

1.一个元素的地址。因为指针本身就是用来存储地址

2.一个一级指针。用指针接受指针无可厚非。

3.一个一维数组。将数组名传过去，数组名表示首元素地址，用指针接收也非常合适。

注意：这里不能将二维数组传过去，因为二维数组名表示第一行数组的地址，无法用一个指针接收

二级指针传参与上面同理：

1.使用二级指针

2.将一级指针进行&在进行传参

3.传指针数组（下图例子为char*类型的指针数组，形参用char**接收）

 

test1函数接收的是二维数组第一行的地址

 test2函数接收的是整个二维数组的地址。

函数指针：指向函数的指针

                                              两种写法都能打印出函数的地址，表示的意义相同。（这里与arr，&arr区分开）

（*pf）是个指针，指向函数参数int类型，返回类型是int

将Add赋值给pf，说明pf和Add等价。所以*加不加无所谓，都可以实现加法运算。但是一旦加上*符号，要用括号括起来。函数指针的类型位int（*）（int，int）

调用0地址处的函数（假设0是个地址，将0强制转换为函数进行访问，操作系统内部有权限访问）

对于一个函数声明，需要交待清楚函数返回类型，函数名，参数

函数指针数组

在函数指针的基础上加个 [4] ,就变为函数指针数组。注意：函数参数类型与函数返回类型必须一致，因为数组是存放一组相同类型元素的集合

函数指针数组的应用——计算器

void menu()
{
	printf("**************************\n");
	printf("****  1.add   2.sub   ****\n");
	printf("****  3.mul   4.div   ****\n");
	printf("****  0.exit          ****\n");
	printf("**************************\n");
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;

	//转移表
	int (*pfArr[])(int, int) = {0, Add, Sub, Mul, Div};

	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器\n");
		}
		else if(input >= 1 && input<=4)
		{
			printf("请输入2个操作数:>");
			scanf("%d%d", &x, &y);	
			ret = pfArr[input](x, y);
			printf("ret = %d\n", ret);
		}
		else
		{
			printf("选择错误\n");
		}

	} while (input);

	return 0;
}

 这里的 函数指针数组 的作用叫做转移表，起到了跳转的作用。但也有一定的局限性，只有当这些函数参数返回值类型一致的时候，使用函数指针数组才简便。

指向函数指针数组的指针

 

指向函数指针数组的指针的过程

 回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个

函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数

的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进

行响应

再次用计算器运用回调函数，减少函数冗余，这里用到calc（计算函数）。不用多余的写scanf

int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}


void menu()
{
	printf("**************************\n");
 printf("****  1.add   2.sub   ****\n");
	printf("****  3.mul   4.div   ****\n");
	printf("****  0.exit          ****\n");
	printf("**************************\n");
}

void calc(int (*pf)(int,int))
{
	int x = 0;
	int y = 0;
	int ret = 0;

	printf("请输入2个操作数:>");
	scanf("%d%d", &x, &y);
	ret = pf(x, y);
	printf("ret = %d\n", ret);
}

int main()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(Add);
			break;
		case 2:
			calc(Sub);
			break;
		case 3:
			calc(Mul);
			break;
		case 4:
			calc(Div);
		break;
	case 0:
			printf("退出计算器\n");
		break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

	return 0;
}

qsort函数（msdn上查找）

void qsort( void *base，              //待排序数据的起始位置

size_t num,                                   //待排序数组的元素个数

size_t width,                                  //一个元素的字节大小

int (*cmp)(const void *e1, const void *e2 )       //函数指针                                              cmp是比较函数，e1，e2是待比较两个元素的地址。int返回值会返回三种类型的值 ( >0  <0  ==0 )

下面演示qsort函数，它是一个库函数，基于快速排序算法实现的一个排序函数。（之前写的冒泡排序只能排列整型数组，若遇到字符型，浮点型数组，结构体数组无法排序） 

struct Stu
{
	char name[20];
	int age;
	double score;
};

int cmp_stu_by_age(const void* e1, const void*e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp( ((struct Stu*)e1)->name , ((struct Stu*)e2)->name);
}

//abcdef
//abq

//使用qsort排序结构体
void test3()
{
	struct Stu arr[3] = { {"zhangsan", 20, 55.5},{"lisi", 30, 88.0},{"wangwu", 10, 90.0}};
	int sz = sizeof(arr) / sizeof(arr[0]);
	//qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}

void*指针可以接受任意类型的数据

 通过MSDN查阅可知，默认e1

下面模拟实现qsort函数 

 指针和数组笔试题

//一维数组
int a[] = { 1,2,3,4 };
              0 1 2 3

 printf("%d\n", sizeof(a));          //4*4 = 16
    printf("%d\n", sizeof(a + 0));     //4/8 a+0是数组第一个元素的地址，是地址，大小就是4/8个字节
    printf("%d\n", sizeof(*a));       //4 a表示数组首元素的地址，*a表示数组的第一个元素，sizeof(*a)就是第一个元素的大小-4
    printf("%d\n", sizeof(a + 1));   //4/8 a表示数组首元素的地址，a+1数组第二个元素的地址，sizeof(a+1)就是第二个元素的地址的大小
    printf("%d\n", sizeof(a[1]));  //4 计算的是第二个元素的大小
    printf("%d\n", sizeof(&a));   //4/8 &a取出的是数组的地址，数组的地址也是地址呀，是地址大小就是4/8字节
    printf("%d\n", sizeof(*&a));  //16 计算的整个数组的大小 ，&表示拿到了地址，*通过地址找回来，一来一去相当于抵消
    printf("%d\n", sizeof(&a + 1));//4/8  &a是数组的地址，+1跳过整个数组，产生的4后边位置的地址
    printf("%d\n", sizeof(&a[0]));//4/8 取出的数组第一个元素的地址
    printf("%d\n", sizeof(&a[0] + 1));//4/8 数组第二个元素的地址

//字符数组
    char arr[] = { 'a','b','c','d','e','f' };

    printf("%llu\n", sizeof(arr));//6
    printf("%llu\n", sizeof(arr + 0));//4/8 arr + 0是数组首元素的地址
    printf("%llu\n", sizeof(*arr));//1 - *arr是首元素，首元素是一个字符，大小是一个字节
    printf("%llu\n", sizeof(arr[1]));//1 - arr[1]是数组的第二个元素，大小是1个字节
    printf("%llu\n", sizeof(&arr));//4/8 &arr是数组的地址
    printf("%llu\n", sizeof(&arr + 1));//4/8 &arr + 1是从数组地址开始向后跳过了整个数组产生的一个地址
    printf("%llu\n", sizeof(&arr[0] + 1));//4/8 &arr[0] + 1 是数组第二个元素的地址

---

char arr[] = "abcdef";   // [a b c d e f \0]

   printf("%d\n", sizeof(arr));//7
    printf("%d\n", sizeof(arr + 0));//4/8 arr+0是数组首元素的地址
    printf("%d\n", sizeof(*arr));//1 - *arr 数组的首元素
    printf("%d\n", sizeof(arr[1]));//1 arr[1]数组的第二个元素
    printf("%d\n", sizeof(&arr));//4/8 - &arr数组的地址，但是数组的地址依然是地址，是地址大小就是4/8
    printf("%d\n", sizeof(&arr + 1));//4/8 - &arr + 1是\0后边的这个地址
    printf("%d\n", sizeof(&arr[0] + 1));//4/8 - &arr[0] + 1是数组第二个元素的地址

---

 char arr[] = { 'a','b','c','d','e','f' };

    printf("%d\n", strlen(arr));//随机值，arr数组中没有\0，所以strlen函数会继续往后找\0，统计\0之前出现的字符个数
    printf("%d\n", strlen(arr + 0));//随机值，arr+0还是数组首元素的地址
    printf("%d\n", strlen(*arr));//err - arr是数组首元素的地址，*arr是数组的首元素，‘a’-97
    printf("%d\n", strlen(arr[1]));//err -'b' - 98
    printf("%d\n", strlen(&arr));//随机值
    printf("%d\n", strlen(&arr + 1));//随机值
    printf("%d\n", strlen(&arr[0] + 1));//随机值

这里说明一下两个err的原因：因为指针变量本身就是用来接收地址的，无论传给什么东西，它都一律按照地址来进行处理。因为‘a’的ASCII值为97，所以指针就把97当作地址开始往后读取直到读到\0，这时就已经造成了访问错误（使用者没有权限去访问这些内存，是留给内核去使用的），形成了野指针。

---

char arr[] = "abcdef"; 

    printf("%d\n", strlen(arr));//6
    printf("%d\n", strlen(arr + 0));//6
    //printf("%d\n", strlen(*arr));//err  *arr就是 ‘a’ -97，非法访问
    //printf("%d\n", strlen(arr[1]));//err
    printf("%d\n", strlen(&arr));//6  将整个数组交给strlen，数到\0之前
    printf("%d\n", strlen(&arr + 1));//随机值
    printf("%d\n", strlen(&arr[0] + 1));//5

总结： sizeof是一个操作符
           sizeof 计算的是对象所占内存的大小-单位是字节,size_t
            不在乎内存中存放的是什么，只在乎内存大小

           strlen 库函数
        求字符串长度，从给定的地址向后访问字符，统计\0之前出现的字符个数

   char* p = "abcdef";

   printf("%d\n", sizeof(p));//4/8  p是指针变量，计算的是指针变量的大小
    printf("%d\n", sizeof(p + 1));//4/8 p+1是'b'的地址
    printf("%d\n", sizeof(*p)); //1  - *p 其实就是'a'
    printf("%d\n", sizeof(p[0]));//1 - p[0]-> *(p+0)-> *p
    printf("%d\n", sizeof(&p));//4/8 &p 是指针变量p在内存中的地址
    printf("%d\n", sizeof(&p + 1));//4/8 - &p+1是跳过p之后的地址
    printf("%d\n", sizeof(&p[0] + 1));//4/8 &p[0]是‘a’的地址，&p[0]+1就是b的地址

---

    printf("%d\n", strlen(p));//6  p存的是 ‘a’ 的地址
    printf("%d\n", strlen(p + 1));//5 从b的位置开始向后数字符
    printf("%d\n", strlen(*p));  //err   *p 其实就是'a'
    printf("%d\n", strlen(p[0]));//err
    printf("%d\n", strlen(&p));//随机值  对象是p（0x |00| 14| 55）地址是随机值
    printf("%d\n", strlen(&p + 1));//随机值
    printf("%d\n", strlen(&p[0] + 1));//5  从b的位置开始向后数字符

    二维数组
    int a[3][4] = { 0 };

    printf("%d\n", sizeof(a));//计算的是整个数组的大小，单位是字节3*4*4 = 48
    printf("%d\n", sizeof(a[0][0]));//4 第1行第一个元素的大小
    printf("%d\n", sizeof(a[0]));//16 - a[0]是第一行的数组名，sizeof(a[0])就是第一行的数组名单独放在sizeof内部，计算的是第一行的大小
    printf("%d\n", sizeof(a[0] + 1));//4/8 a[0]作为第一行的数组名，并没有单独放在sizeof内部，也没有被取地址
    所以a[0]就是数组首元素的地址，就是第一行第一个元素的地址，a[0]+1就是第一行第二个元素的地址

    printf("%d\n", sizeof(*(a[0] + 1)));//4 - *(a[0] + 1))表示的是第一行第二个元素
    printf("%d\n", sizeof(a + 1));//4/8 - a表示首元素的地址，a是二维数组，首元素的地址就是第一行的地址
    所以a表示的是二维数组第一行的地址，a+1就是第二行的地址
    printf("%d\n", sizeof(*(a + 1)));//16 对第二行的地址解引用访问到就是第二行
    *(a+1) -> a[1]
    sizeof(a[1])
    
    printf("%d\n", sizeof(&a[0] + 1));//4/8 - a[0]是第一行的数组名，&a[0]取出的就是第一行的地址
    &a[0] + 1 就是第二行的地址

    printf("%d\n", sizeof(*(&a[0] + 1)));//16 - 对第二行的地址解引用访问到就是第二行
    printf("%d\n", sizeof(*a));//16 - a就是首元素的地址，就是第一行的地址，*a就是第一行
    *a - > *(a+0) -> a[0]

    printf("%d\n", sizeof(a[3]));//16 int [4]

    int a = 10;
    printf("%d\n", sizeof(a));//4
    printf("%d\n", sizeof(int));//4

指针笔试题 

Test1 

Test2

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 );                           00 100014                             结构体指针+1，加20个字节，注意转换为16进制

printf ( "%p\n" , ( unsigned long ) p + 0x1 );  00 100001      这里p被强制转化为整形，整形+1就只是+1  只有是指针类型，才考虑+1到底加了多少个字节

printf ( "%p\n" , ( unsigned int* ) p + 0x1 );   00 100004    这里p被强制转化为整型指针，+1相当于加4个字节

Test3

 Test4

这里是用小括号括起来的，是逗号表达式。

 Test5

数组指针

%p打印出来的是地址 ，所以打印的是-4在内存中存储的地址，将原码反码补码写出来，将补码视为地址打印出来。

%d        两个相同类型的指针相减，得到的是它们之间元素的个数。因为是低地址-高地址，所以是负数。