目录
一、字符指针
指针类型中 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 2 3 4 5
2 3 4 5 6
3 4 5 6 7
0 0 0 0 0三、数组指针
1.数组指针的定义
整形指针——存放整形地址的指针——指向整形的指针——char *
字符指针——存放字符地址的指针——指向字符的指针——int *
数组指针——存放数组地址的指针——指向数组的指针
int main()
{
char ch = 'w';
char* pc = &ch;
int num = 10;
int* pi = #
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个元素，每个元素为char3.数组指针的使用
学习了数组指针，那么数组指针有什么用处，该怎么用呢？
一种鸡肋用法：
#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 10p表示数组的地址，它有能力访问所有元素，(*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;
}关键是画图理解
872
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
