c语言---指针进阶
目录
一、字符指针
二、指针数组
三、数组指针
1.数组指针的定义
2.&数组名VS数组名
3.数组指针的使用
四、数组参数、指针参数
1.一维数组传参
2.二维数组传参
3.一级指针传参
4.二级指针传参
五、函数指针
六、函数指针数组
七、指向函数指针数组的指针
八、回调函数
1.引入
2 .演示qsort函数的使用
3.使用回调函数，模拟实现qsort（采用冒泡的方式）
4.从qsort函数的原理去模拟
5.使用qsort排序结构体
九、sizeof（）和strlen（）在数组大小的区别
十、指针笔试题
笔试题1
笔试题2
笔试题3
笔试题4
笔试题5
笔试题6
笔试题7
笔试题8
一、字符指针
在指针的类型中我们知道有一种指针类型为字符指针 char*
一般使用：
int main()
{
char ch = 'w';
char* pc = &ch;
*pc = 'a';
printf("%c\n", ch);
return 0;
}int main()
{
const char* p = "abcdef";//常字符串不能直接修改
//*p = 'w'; //err 出错
printf("%c\n", *p); //打印一个字符
printf("%s\n", p); //打印一个字符串 只需要把其首地址给出
return 0;
}还有一种使用方式如下：
int main()
{
const char* pstr = "hello bit.";//这里是把一个字符串放到pstr指针变量里了吗？
printf("%s\n", pstr);
return 0;
}代码 const char* pstr = "hello bit.";特别容易认为是把字符串 hello bit .放到字符指针 pstr 里了，但是本质是把字符串 hello bit. 首字符的地址放到了pstr中。
因此上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。
面试题举例：
int main()
{
const char* p1 = "abcdef"; //与const无关 不影响答案
const char* p2 = "abcdef";
char arr1[] = "abcdef";//加不加const结果都一样的
char arr2[] = "abcdef";
if (p1 == p2)
{
printf("p1 == p2\n");
}
else
{
printf("p1 != p2\n");
}
if (arr1 == arr2)
{
printf("arr1 == arr2\n");
}
else
{
printf("arr1 != arr2\n");
}
return 0;
}输出结果是：
p1 == p2
arr1 != arr2
二、指针数组
指针数组是一个存放指针的数组。下面指针数组是什么意思？
int* arr1[10]; //整形指针数组
char *arr2[4]; //一级字符指针数组
char **arr3[5];//二级字符指针数组
int main()
{
//int* arr[10];//存放整型指针的数组
//char* ch[5]; //存放字符指针的数组
int a = 10;
int b = 20;
int c = 30;
int* p1 = &a;
int* p2 = &b;
int* p3 = &c;
int* arr[3] = { &a, &b, &c };//arr就是一个指针数组
int i = 0;
for (i = 0; i < 3; i++)
{
printf("%d ", *(arr[i]));
}
return 0;
}输出结果是：10 20 30
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* parr[3] = { arr1, arr2, arr3 };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf("%d ", parr[i][j]);
printf("%d ", *(parr[i]+j));
}
printf("\n");
}
return 0;
}输出结果：
1 1 2 2 3 3 4 4 5 5
2 2 3 3 4 4 5 5 6 6
3 3 4 4 5 5 6 6 7 7
int arr[5];
arr是一个整形数组，每个元素是int类型的，有5个元素int* parr1[10];
parr1是一个数组，数组10个元素，每个元素的类型是int*int(*parr2)[10];
parr2是一个指向数组的指针，指向的数组有10个元素，每个元素的类型是intint(* parr3[10])[5];
parr3 是一个数组，数组有10个元素，每个元素的类型是：int(*)[5]
parr3是存放数组指针的数组
三、数组指针
1.数组指针的定义
数组指针是指针？还是数组？ 答案是：指针。
int main()
{
int a = 10;
int *p = &a; //整型指针 - 指向整型的指针， 存放整型变量地址的
char ch = 'w';
char* pc= &ch; //字符指针 - 指向字符的指针，存放的是字符变量的地址
return 0;
}那数组指针应该是：能够指向数组的指针。
int *p1[10];
int (*p2)[10];
//p1, p2分别是什么？
解释：int (*p)[10];
p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。
2.&数组名VS数组名
数组名该怎么理解呢？
通常情况下，我们说的数组名都是数组首元素的地址
但是有2个例外：
1. sizeof(数组名)，这里的数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小
2. &数组名，这里的数组名表示整个数组，&数组名，取出的是整个数组的地址
int main()
{
int arr[10] = {0};
//数组是首元素的地址
printf("%p\n", arr);
printf("%p\n", arr+1);
printf("%p\n", &arr[0]);
printf("%p\n", &arr[0]+1);
printf("%p\n", &arr);
printf("%p\n", &arr+1);
return 0;
}输出结果：
0079F8E0
0079F8E4
0079F8E0
0079F8E4
0079F8E0
0079F908
3.数组指针的使用
既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
#include
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
return 0;
}
但是我们一般很少这样写代码。
下面写一个函数打印arr数组的内容
//形参写出数组
void print1(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
//形参写成指针的形式
void print1(int* arr, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(arr + i));
}
printf("\n");
}
//这不是推荐的写法
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 };
int sz = sizeof(arr) / sizeof(arr[0]);
print1(arr, sz);
return 0;
}一个数组指针在二维数组的使用：
数组名arr表示首元素的地址，但是二维数组的首元素是二维数组的第一行，所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址，可以数组指针来接收。
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]);
}
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; //数组指针
print2(arr, 3, 5);
return 0;
}
四、数组参数、指针参数
1.一维数组传参
#include
void test(int arr[])//对
{}
void test(int arr[10])//对
//数组传参只是传递首元素的地址 并不会创建一个数组 所以这个10有没有都行 没有影响
{}
void test(int *arr)//对
{}
void test2(int *arr[20])//对 这个20和上面一个道理
{}
void test2(int **arr)//对
{}
int main()
{
int arr[10] = {0};
int *arr2[20] = {0};
test(arr);
test2(arr2);
}
2.二维数组传参
void test(int arr[3][5])//对
{}
void test(int arr[][])//错
{}
void test(int arr[][5])//对 行可以省列不可以省
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。这样才方便运算。
void test(int *arr)//错
{}
void test(int* arr[5])//错
{}
void test(int (*arr)[5])//对
{}
void test(int **arr)//错
{}
int main()
{
int arr[3][5] = {0};
test(arr);
}二级指针存放一级指针的地址，数组指针存放数组的地址。
3.一级指针传参
void test(int* ptr, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *ptr);
ptr++;
}
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
test(p, sz);//p是一级指针
return 0;
}int main()
{
int arr[3][5];
test1(arr);//传递的第一行的地址
test2(&arr);//传递的是整个二维数组的地址
return 0;
}思考：当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
比如：
void test1(int *p)
{}
//test1函数能接收什么参数？
void test2(char* p)
{}
//test2函数能接收什么参数？4.二级指针传参
#include
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
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
} 输出结果是：
00007FF7B2A913C0
00007FF7B2A913C0
输出的是两个地址，这两个地址是 test 函数的地址。
int Add(int x, int y)
{
return x + y;
}
int main()
{
int arr[10];
int (*p)[10] = &arr;//p是一个数组指针变量
printf("%p\n", &Add);
printf("%p\n", Add);
int (* pf)(int, int) = Add;//就是函数指针变量
int ret1 = (*pf)(2,3);
int ret2 = Add(2, 3);
int ret3 = pf(2, 3);
printf("%d %d %d\n", ret1,ret2,ret3);
return 0;
}输出结果：
005D11BD
005D11BD
5 5 5
那我们的函数的地址要想保存起来，怎么保存？
void test()
{
printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();
首先，能存储地址，就应该知道pfun1和pfun2是不是指针，哪个是指针。
答案是：pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。
int main()
{
//代码1 ( *( void (*)() )0 )();
void (*)() //是函数指针类型
void (*p)()
( void (*)() ) // ( 类型 ) 格式就是强制类型转换
( void (*)() )0 //对0进行强制类型的转换
//0x0012ff40
( *( void (*)() )0 )();
//1. 首先是把0强制类型转换为一个函数指针类型，这就意味着0地址处放一个返回类型是void，无参的一个函数
//2. 调用0地址处的这个函数
int Add(int, int); //函数类型声明
//代码2
void (* signal(int, void(*)(int)) )(int); //函数声明
typedef void(* pf_t)(int) ;//给函数指针类型void(*)(int)重新起名叫：pf_t
pf_t signal(int, pf_t); //然后就转换为这样的
//signal是一个函数的声明
//signal函数的参数，第一个是int类型的，第二个是void(*)(int)的函数指针类型
//signal函数的返回值类型也是：void(*)(int)的函数指针
return 0;
}
六、函数指针数组
要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？
int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];
答案是：parr1
parr1 先和 [] 结合，说明 parr1是数组，数组的内容是什么呢？ 是 int (*)() 类型的函数指针。
函数指针数组的用途：转移表
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;
}
int main()
{
char* arr[5]; //字符指针数组
int* arr2[4]; //整形指针数组
int (*pf1)(int, int) = Add;
int (*pf2)(int, int) = Sub;
int (*pf3)(int, int) = Mul;
int (*pf4)(int, int) = Div;
//函数指针数组
int (* pf[4])(int, int) = { Add, Sub, Mul, Div };
int i = 0;
for (i = 0; i < 4; i++)
{
int ret = pf[i](8, 2);
printf("%d\n", ret);
}
return 0;
}
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");
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
switch (input)
{
case 1:
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = Add(x, y);
printf("ret = %d\n", ret);
break;
case 2:
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = Sub(x, y);
printf("ret = %d\n", ret);
break;
case 3:
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = Mul(x, y);
printf("ret = %d\n", ret);
break;
case 4:
printf("请输入2个操作数:>");
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;
}使用函数指针数组的实现：
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");
}
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;
}七、指向函数指针数组的指针
指向函数指针数组的指针是一个指针。指针指向一个数组 ，数组的元素都是函数指针 。
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;
}int main()
{
int arr[10] = {1,2,3,4,5,6,7};
int(*p)[10] = &arr;//p得是数组指针
//函数指针
int (*pf)(int, int) = &Add;
//函数指针数组
int (* pfarr[4])(int, int);
int (* (*p3)[4])(int, int) = &pfarr;//p3是一个指向函数指针数组的指针
return 0;
}#include
#include
#include
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;
}
int main()
{
//函数指针数组
int (*pfarr[4])(int, int) = {Add,Sub,Mul,Div};
//p3是一个指向函数指针数组的指针
int (*(* p3)[4])(int, int) = &pfarr;
int i =0;
for (i = 0; i < 4; i++)
{
//*p
//*(p3+0)
//p3[0]
int ret = p3[0][i](3, 4); //int ret = (*p3)[i](3,4);
printf("%d\n", ret);
}
return 0;
} 
八、回调函数
1.引入
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个 函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数 的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进 行响应。
void test()
{
printf("hehe\n");
}
void print_hehe(void (*p)()) //p是一个函数指针
{
if (1)
p();
}
int main()
{
print_hehe(test);
return 0;
}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;
}
2 .演示qsort函数的使用
void qsort(void* base,
size_t num,
size_t width,
int(*cmp)(const void* e1, const void* e2)//函数指针
);
#include
//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;
} 3.使用回调函数，模拟实现qsort（采用冒泡的方式）
void bubble_sort(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (j = 0; j < sz-1-i; j++)
{
if (arr[j] > arr[j + 1])
{
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}
void print_arr(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
void test1()
{
int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
//排序为升序
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz);
print_arr(arr, sz);
}
int main()
{
test1();
return 0;
}4.从qsort函数的原理去模拟
#include
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 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;
} 5.使用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);
}
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);
}
int main()
{
test3();
return 0;
}#include
#include
#include
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);
}
void Swap(char* buf1, char* buf2, int width)
{
int i = 0;
for (i = 0; i < width; i++)
{
char tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
void bubble_sort(void* base, int num, int width, int (*cmp)(const void* e1, const void* e2))
{
int i = 0;
for (i = 0; i < num - 1; i++)
{
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
//if (arr[j] > arr[j + 1]) //进行比较
if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
{
//交换
Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
}
}
}
}
void test5()
{
struct Stu arr[3] = { {"zhangsan", 20, 55.5},{"lisi", 30, 88.0},{"wangwu", 10, 90.0} };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
test5();
return 0;
} 
九、sizeof（）和strlen（）在数组大小的区别
sizeof是一个操作符
sizeof 计算的是对象所占内存的大小-单位是字节,size_t
不在乎内存中存放的是什么，只在乎内存大小strlen 库函数
求字符串长度，从给定的地址向后访问字符，统计\0之前出现的字符个数
#include
#include
int main()
{
//一维数组
int a[] = { 1,2,3,4 };
int (*p)[4] = &a;
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' };//[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));//随机值
//Unsigned long long ->llu
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 是数组第二个元素的地址
return 0;
} #include
#include
int main()
{
char arr[] = "abcdef";
//[a b c d e f \0]
printf("%d\n", strlen(arr));//6
printf("%d\n", strlen(arr + 0));//6
//printf("%d\n", strlen(*arr)); //err错误
//printf("%d\n", strlen(arr[1])); //err错误
//printf("%d\n", strlen(&arr));//6
//printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//5
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是数组第二个元素的地址
const char* p = "abcdef";
printf("%d\n", strlen(p));//6
printf("%d\n", strlen(p + 1));//5 从b的位置开始向后数字符
//printf("%d\n", strlen(*p)); //err
//printf("%d\n", strlen(p[0]));//err
//printf("%d\n", strlen(&p));//随机值
//printf("%d\n", strlen(&p + 1));//随机值
printf("%d\n", strlen(&p[0] + 1));//5 从b的位置开始向后数字符
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的地址
//二维数组
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 n = 10;
printf("%d\n", sizeof(a));//4
printf("%d\n", sizeof(int));//4
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, 5
笔试题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;
}
输出结果是:
0000000000000020
0000000000000001
0000000000000004
笔试题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 2000000
笔试题4
#include
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;
}
输出结果：10，5
笔试题7
int main()
{
char *a[] = {"work","at","alibaba"};
char**pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}
笔试题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;
}