【C语言】指针进阶

作者简介：大家好我是狂暴于涛侠本侠
隸个人主页：狂暴于涛侠
支持我：点关注不迷路提高彼此亲密度

指针的主题，我们在初级阶段的《指针》章节已经接触过了，我们知道了指针的概念：

指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
指针的大小是固定的4/8个字节（32位平台/64位平台）。
指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
指针的运算。

如果不知道的小伙伴可以点这里查看.
類让我们来看看C语言中指针都有什么猫腻冲冲冲！！！

指针的进阶

類1. 字符指针
類2. 数组指针
類3. 指针数组
- 3.1 数组指针的定义
- 3.2 &数组名VS数组名
- 3.3 数组指针的使用
類4. 数组传参和指针传参
- 4.1 一维数组传参
- 4.2 二维数组传参
- 4.3 一级指针传参
- 4.4 二级指针传参
類5. 函数指针
類6. 函数指针数组
類7. 指向函数指针数组的指针
類8. 回调函数
- 8.2 qsort函数的使用
類9. 指针和数组面试题的解析
類10. 指针笔试题

類1. 字符指针

在指针的类型中我们知道有一种指针类型为字符指针 char* ;

int main()
{
    char ch = 'w';
    char *pc = &ch;
    *pc = 'w';
    return 0;
}
还有一种写法int main()
{
    const char* pstr = "hello bit.";//这里是把一个字符串放到pstr指针变量里了吗？
    printf("%sn", pstr);
    return 0;
}

解释

代码 const char* pstr = “hello bit.”; 特别容易让同学以为是把字符串 hello bit 放到字符指针 pstr 里了，但是/本质是把字符串 hello
bit. 首字符的地址放到了pstr中。

上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。

可以通过下面的练习题理解一下

#include 
int main()
{
    char str1[] = "hello bit.";
    char str2[] = "hello bit.";
    const char *str3 = "hello bit.";
    const char *str4 = "hello bit.";
    if(str1 ==str2)
 printf("str1 and str2 are samen");
    else
 printf("str1 and str2 are not samen");
       
    if(str3 ==str4)
 printf("str3 and str4 are samen");
    else
 printf("str3 and str4 are not samen");
       
    return 0;
}

解释
这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当
几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化
不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不同。

類2. 数组指针

在《指针》章节学了指针数组，指针数组是一个存放指针的数组。
这里我们再复习一下，下面指针数组是什么意思？

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组

類3. 指针数组 3.1 数组指针的定义

数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：
整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。

下面代码哪个是数组指针？

int *p1[10];
int (*p2)[10];

int (*p)[10];//是数组指针

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

3.2 &数组名VS数组名

对于下面的数组：
int arr[10];
arr 和 &arr 分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？
我们看一段代码：

#include 
int main()
{
    int arr[10] = {0};
    printf("%pn", arr);
    printf("%pn", &arr);
    return 0;
}

结果为

可见数组名和&数组名打印的地址是一样的。
难道两个是一样的吗？
我们再看一段代码：

#include 
int main()
{
 int arr[10] = { 0 };
 printf("arr = %pn", arr);
 printf("&arr= %pn", &arr);
 printf("arr+1 = %pn", arr+1);
 printf("&arr+1= %pn", &arr+1);
 return 0;
}

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

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

3.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;
}

一个数组指针的使用：

#include 
void print_arr1(int arr[3][5], int row, int col)
{
    int i = 0;
    for(i=0; i
        for(j=0; 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
        for(j=0; 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;
}

類4. 数组传参和指针传参

在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？

4.1 一维数组传参

#include 
void test(int arr[])
{}
void test(int arr[10])
{}
void test(int *arr)
{}
void test2(int *arr[20])
{}
void test2(int **arr)
{}
int main()
{
 int arr[10] = {0};
 int *arr2[20] = {0};
 test(arr);
 test2(arr2);
}

4.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);
}

4.3 一级指针传参

//遍历数组
#include 
void print(int *p, int sz)
{
 int i = 0;
 for(i=0; i
 printf("%dn", *(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;
}

思考：

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

void test1(int *p)
{}
int ch =60;
int* p1 = &ch;
test2(&ch);
test2(p1);


void test2(char* p)
{}

char ch ='w';
char* p1 = &ch;
test2(&ch);//就是char*
test2(p1);

4.4 二级指针传参

//用函数二级指针接收
void test(int** p2)
{
	//   p2 == ** ppa
	// * p2 == *pa
	//** p2 == a
	**p2 = 20;
}
int main()
{
	int a = 10;
	int* pa = &a;//pa是一级指针
	int** ppa = &pa;//ppa是二级指针
	//ppa用什么函数接收呢？
	test(ppa);
	return 0;
}

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

//对于上个例子来说
	test(&pa);//传一级指针变量的地址
	//pa本来就是一级指针变量，&后就是二级地址

	int* arr[10] = {0};
	test(arr);//传存放一级指针的数组
	//arr是数组名，本身就是首元素地址再加上之前int* arr[10] 所以实际上也是 ** arr....
	printf("%dn", a);//?
	//逻辑可以但实测不行，指针数组中存在野指针会导致代码挂掉

总结
当函数的参数为二级指针的时候，可以接收什么参数？
1.二级地址
2.传一级指针变量的地址
3.传存放一级指针的数组

類5. 函数指针

首先看一段代码：

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

int main()
{
	printf("%pn", &Add);
	printf("%pn", Add);

	return 0;
}

注意下面的关系

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

int main()
{
    //函数指针 - 存放函数地址的指针
	//&函数名 - 取到的就是函数的地址
	// 
	//pf就是一个函数指针变量
	//以下两种写法都可
	int (*pf)(int, int) = &Add;
	int (*pf)(int, int) = Add;//Add能放到pf中说明  Add==pf
//前面int是说这个函数返回值是int    后面两个int是传入的两个参数类型 

	//	对pf解引用后就是函数本身这时候将3,5传入计算
    int ret = (*pf)(3, 5);//得数为8   （********pf）同样可以所以这个式子中*4多少没有实际意义 只是为了让我们理解这是个指针
    int ret = Add(3,5);   //得数为8   Add能放到pf中说明  Add==pf 所以得出下面式子
    int ret = pf(3, 5);//得数为8
    
    // 以下写法不对     先执行的是pf（3,5）得数是8 后再解引用
    int ret =*pf(3,5);
    
	return 0;
}

你能看明白下面小题么？

1. (*(void(*)()0))(); 是什么意义？
2. void (signal(int, void()(int)))(int);
解释

(*(void(*)()0))()
void (*)()是一种函数指针类型
实际上是对0进行强制转换  void (*)()0  (*)带表指针类型 ()代表是函数  void 是返回值类型
该函数无参数，返回值是void  
将0转化为一个返回值是void 的函数地址  后对0地址进行解引用*(void(*)()0)  
调用0地址处的函数(*(void(*)()0))()

void (*signal(int, void(*)(int)))(int);
1. signal 和()先结合，说明signal是函数名
2. signal函数的第一个参数的类型是int,第二个参数的类型是函数指针
 该函数指针，指向一个参数为int,返回类型是void的函数
3. signal函数的返回类型也是一个函数指针
 该函数指针，指向一个参数为int,返回类型是void的函数

对于void (*signal(int, void(*)(int)))(int);可以简化
typedef void(*pfun_t)(int) ;//对void(*)(int)的函数指针类型重命名为pfun_t
这样写不行------》typedef void(*)(int) pfun_t ;
typedef unsigned int uint;

類6. 函数指针数组

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

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

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

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

int Sub(int x, int y)
{
	return x - y;
}
int main()
{
	int (*pf1)(int, int) = Add;
	int (*pf2)(int, int) = Sub;
	int (*pfArr[2])(int, int) = {Add, Sub};//pfArr就是函数指针数组

	return 0;
}

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

那么函数指针数组的应用是什么样的呢？

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;
	//计算器-计算整型变量的加、减、乘、除

	do {
		menu();
		
		int x = 0;
		int y = 0;
		int ret = 0;
		printf("请选择:>");
		scanf("%d", &input);

		switch (input)
		{
		case 1:
			printf("请输入2个操作数>:");
			scanf("%d %d", &x, &y);
			ret = Add(x, y);
			printf("ret = %dn", ret);
			break;
		case 2:
			printf("请输入2个操作数>:");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("ret = %dn", ret);
			break;
		case 3:
			printf("请输入2个操作数>:");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("ret = %dn", ret);
			break;
		case 4:
			printf("请输入2个操作数>:");
			scanf("%d %d", &x, &y);
			ret = Div(x, y);
			printf("ret = %dn", ret);
			break;
		case 0:
			printf("退出程序n");
			break;
		default:
			printf("选择错误，重新选择!n");
			break;
		}
		
	} while (input);
	return 0;
}
这样写没问题但是太麻烦了，代码冗余，而且添加新的功能也比较麻烦
将main函数这样改进
int main()
{
	int input = 0;
	do {
		menu();
		//pfArr就是函数指针数组
		//这个其实就是转移表 - 《C和指针》这本书中有提到
		int (*pfArr[5])(int, int) = { NULL, Add, Sub, Mul, Div };
		int x = 0;
		int y = 0;
		int ret = 0;
		printf("请选择:>");
		scanf("%d", &input);//2

		if (input >= 1 && input <= 4)
		{
			printf("请输入2个操作数>:");
			scanf("%d %d", &x, &y);
			ret = (pfArr[input])(x, y);
			printf("ret = %dn", ret);
		}
		else if(input == 0)
		{
			printf("退出程序n");
			break;
		}
		else
		{
			printf("选择错误n");
		}
	} while (input);
	return 0;
}

類7. 指向函数指针数组的指针

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

void test(const char* str)
{
 printf("%sn", 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;
 (*ppfunArr)[5]
 return 0;
}

類8. 回调函数

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

利用回调函数优化面函数

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 Calc(int (*pf)(int, int))
{
	int x = 0;
	int y = 0;
	printf("请输入2个操作数>:");
	scanf("%d %d", &x, &y);
	return pf(x, y);
}

int main()
{
	int input = 0;
	//计算器-计算整型变量的加、减、乘、除
	//a&b a^b a|b a>>b a<b

	do {
		menu();
	
		int ret = 0;
		printf("请选择:>");
		scanf("%d", &input);

		switch (input)
		{
		case 1:
			ret = Calc(Add);
			printf("ret = %dn", ret);
			break;
		case 2:
			ret = Calc(Sub);
			printf("ret = %dn", ret);
			break;
		case 3:
			ret = Calc(Mul);//
			printf("ret = %dn", ret);
			break;
		case 4:
			ret = Calc(Div);//
			printf("ret = %dn", ret);
			break;
		case 0:
			printf("退出程序n");
			break;
		default:
			printf("选择错误，重新选择!n");
			break;
		}
	} while (input);
	return 0;
}

8.2 qsort函数的使用

为了方便大家理解我们先来看一下普通冒泡函数

#define _CRT_SECURE_NO_WARNINGS 1 #include 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]); } printf("n"); } int main() { //升序 int arr[10] = { 9,8,7,6,5,4,3,2,1,0 }; int sz = sizeof(arr) / sizeof(arr[0]); print_arr(arr, sz); bubble_sort(arr, sz); print_arr(arr, sz); return 0; }

再来看一下 sqort函数的解释

这里写的不规范是方便大家理解 void qsort( //void* p 就是为了存放任意类型的指针但是这种指针类型不能进行解引用操作 void* base, //base中存放的是待排序数据中第一个对象的地址为什么是void因为这样就可以比较很多类型了 size_t num, //排序数据元素的个数 size_t size,//排序数据中一个元素的大小，单位是字节因为这个函数并不知道你要比较的是什么类型 int (*cmp)(const void* e1, const void* e2)//是用来比较待排序数据中的2个元素的函数 void因为这样就可以比较很多类型了 );

以下是实际应用

#include //qsort #include //strcmp是比较两个字符大小 void print_arr(int arr[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } printf("n"); } int cmp_int(const void* e1, const void* e2) { //e1 e2 都是void类型必须转化为（int*）类型再算 return *(int*)e1 - *(int*)e2; } void test1() { //整形数据的排序 int arr[] = { 1,3,5,7,9,2,4,6,8,0}; int sz = sizeof(arr) / sizeof(arr[0]); //排序 qsort(arr, sz, sizeof(arr[0]), cmp_int); //打印 print_arr(arr, sz); } struct Stu { char name[20]; int age; }; int sort_by_age(const void* e1, const void* e2) { return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age; } int sort_by_name(const void*e1, const void*e2) { return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name); } //如果想要降序排列 //int sort_by_name(const void*e1, const void*e2) //{ 直接将这个e1和e2换一下位置就好了其他同理 // return strcmp(((struct Stu*)e2)->name, ((struct Stu*)e1)->name); //} void test2() { //使用qsort函数排序结构体数据 struct Stu s[3] = { {"zhangsan", 30},{"lisi", 34},{"wangwu", 20} }; int sz = sizeof(s) / sizeof(s[0]); //按照年龄来排序 qsort(s, sz, sizeof(s[0]), sort_by_age); //按照名字来排序 qsort(s, sz, sizeof(s[0]), sort_by_name); } int main () { test1(); test2(); }

用自己的方法实现sqort函数

//模仿qsort实现一个冒泡排序的通用算法 void bubble_sort(void* base,int sz,int width,int (*cmp)(const void*e1, const void*e2) ) { int i = 0; //趟数 for (i = 0; i < sz - 1; i++) { //一趟的排序 int j = 0; for (j = 0; j < sz - 1 - i; j++) { //两个元素比较 //arr[j] arr[j+1] //这里为什么要转化为（char*）而不是别的呢？首先（char*）类型是最小的方便 //with计算如果转化为int指针类型后面with加减运算就比较麻烦了 if (cmp( (char*)base+j*width, (char*)base+(j+1)*width )>0) { //交换 Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);//最后一个数是width是因为函数不知道我们要比较的参数所以手动的添加 } } } } 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++; } } int cmp_int(const void* e1, const void* e2) { return *(int*)e1 - *(int*)e2; } void print_arr(int arr[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } printf("n"); } int main() { //整形数据的排序 int arr[] = { 1,3,5,7,9,2,4,6,8,0 }; int sz = sizeof(arr) / sizeof(arr[0]); //排序 bubble_sort(arr, sz, sizeof(arr[0]), cmp_int); //打印 print_arr(arr, sz); }

類9. 指针和数组面试题的解析

首先我们先记住以下规则

sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
&数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
除此之外所有的数组名都表示首元素的地址。

操作系统位数不同计算结果不同
先看下面小题

int a[] = { 1,2,3,4 };//4*4=16 printf("%dn", sizeof(a));//16 整个数组的大小。 printf("%dn", sizeof(a + 0));//4/8 a + 0 是第一个元素的地址，sizeof(a + 0)计算的就是是该地址的大小 printf("%dn", sizeof(*a));//4 a是数组名也就是首元素1的地址解引用后就是1 *a是数组的第一个元素，sizeof(*a)计算的是第一个元素的大小 printf("%dn", sizeof(a + 1));//4/8 a + 1是第二个元素的地址，sizeof(a+1)计算的地址的大小 printf("%dn", sizeof(a[1]));//4 - 计算的是第二个元素的大小 printf("%dn", sizeof(&a)); //4/8 - &a虽然数组的地址，但是也是地址，sizeof(&a)计算的是一个地址的大小 printf("%dn", sizeof(* &a));//16 - 计算的数组的大小先&取地址在*解引用相当于取消了 //&a -- int(*p)[4] = &a; printf("%dn", sizeof(&a + 1));//4/8 - &a + 1 是数组后面的空间的地址 printf("%dn", sizeof(&a[0]));//4/8 1 的地址 printf("%dn", sizeof(&a[0] + 1));//4/8 是2的地址

//字符数组 char arr[] = { 'a','b','c','d','e','f' }; printf("%dn", sizeof(arr));//6 6个字符每个字符1字节 printf("%dn", sizeof(arr + 0));//4/8 就是a的地址注意字符所占空间大小是一个字节但是字符的地址编号也是4个字节 printf("%dn", sizeof(*arr));//1 首元素地址解引用 printf("%dn", sizeof(arr[1]));//1 b的字节数 printf("%dn", sizeof(&arr));//4/8 整个数组的地址也是地址也是4个字节 printf("%dn", sizeof(&arr + 1));//4/8 整个数组后的第一位也就是f后 printf("%dn", sizeof(&arr[0] + 1));//4/8 b的地址 &arr[0]取第一个元素的地址，类型是int* int*类型的指针加一就是跳过一个元素也就是b //strlen函数会从这个数向后找没有就继续找 printf("%dn", strlen(arr));//随机值首元素地址一直向后找 printf("%dn", strlen(arr + 0));//随机值首元素地址一直向后找 printf("%dn", strlen(*arr));// err 正常strlen（char* str）但是就本题而言，*arr是a的值，strlen回去找97地址的位置但根本没有 printf("%dn", strlen(arr[1]));//err 同上 printf("%dn", strlen(&arr));//随机值本来&arr是整个数组地址但是函数strlen（char* str）将数组char(*)[6];传入会转化为字符指针系统会认为这个依然是首字符的地址 printf("%dn", strlen(&arr + 1));//和前面随机值相比随机值-6 printf("%dn", strlen(&arr[0] + 1));//和前面随机值相比随机值-1

char arr[] = "abcdef"; //注意：[a b c d e f ] printf("%dn", sizeof(arr));//7 printf("%dn", sizeof(arr + 0));//4/8 printf("%dn", sizeof(*arr));//a 1 printf("%dn", sizeof(arr[1]));//b 1 printf("%dn", sizeof(&arr));//4/8 char(*)[7] printf("%dn", sizeof(&arr + 1));//4/8 跨过整个数组虽然加一但是类型还是没变 printf("%dn", sizeof(&arr[0] + 1));//4/8 b的地址 printf("%dn", strlen(arr));//6 printf("%dn", strlen(arr + 0));//6 printf("%dn", strlen(*arr));//err 正常strlen（char* str）但是就本题而言，*arr是a的值，strlen回去找97地址的位置但根本没有 printf("%dn", strlen(arr[1]));//err 同上 printf("%dn", strlen(&arr));//6 本来&arr是整个数组地址但是函数strlen（char* str）将数组char(*)[7];传入会转化为字符指针系统会认为这个依然是首字符的地址 printf("%dn", strlen(&arr + 1));//随机值 printf("%dn", strlen(&arr[0] + 1));//5

char* p = "abcdef"; // p是首元素地址 //注意：[a b c d e f ] printf("%dn", sizeof(p));// 4/8 p存放的是a的地址 printf("%dn", sizeof(p + 1));// 4/8 b的地址 printf("%dn", sizeof(*p)); // 1 a的字节 printf("%dn", sizeof(p[0])); //1 p[0]--> *(p+0) 同上 printf("%dn", sizeof(&p));// 4/8 p的地址 printf("%dn", sizeof(&p + 1)); // 4/8 跨过整个p的地址加一 printf("%dn", sizeof(&p[0] + 1));// 4/8 b 的地址 printf("%dn", strlen(p));//6 a向后查到 printf("%dn", strlen(p + 1));//5 b向后查到 printf("%dn", strlen(*p));// 首地址解引用无地址 printf("%dn", strlen(p[0]));// 同上 printf("%dn", strlen(&p));//随机值无法明确指针地址后有多少数字 printf("%dn", strlen(&p + 1));// 随机值和上面随机值没有关系因为无法明确p数组地址中有没有 printf("%dn", strlen(&p[0] + 1));// 5 printf("%dn", strlen(&p)); printf("%dn", strlen(&p + 1));

int a[3][4] = { 0 }; printf("%dn", sizeof(a));//48 = 3*4*sizeof(int) printf("%dn", sizeof(a[0][0]));//4 - a[0][0] - 是第一行第一个元素 printf("%dn", sizeof(a[0]));//16 printf("%dn", sizeof(a[0] + 1));//4 解释：a[0]作为数组名并没有单独放在sizeof内部， //也没取地址,所以a[0]就是第一行第一个元素的地址 //a[0]+1,就是第一行第二个元素的地址 printf("%dn", sizeof(*(a[0] + 1)));//4 整形大小 - 解释：*(a[0] + 1)是第一行第二个元素 printf("%dn", sizeof(a + 1));//4 - 解释：a是二维数组的数组名，代表首元素地址即a[0][0-3]并没有取地址 //也没有单独放在sizeof内部,所以a就表示二维数组首元素的地址，即：第一行的地址 //a + 1就是二维数组第二行的地址看地址类型所以答案是4 printf("%dn", sizeof(*(a + 1)));//16 解释： ==a[1] a+1是第二行的地址，所以*（a+1）表示第二行 //所以计算的就是第2行的大小 printf("%dn", sizeof(&a[0] + 1));//4 解释：a[0]是第一行的数组名， //&a[0]取出的就是第一行的地址,&a[0]+1 就是第二行的地址 printf("%dn", sizeof(*(&a[0] + 1)));// 16 &a[0]+1 就是第二行的地址 //*(&a[0]+1) 就是第二行，所以计算的第二行的大小 printf("%dn", sizeof(*a));//16 解释：== a[0] a作为二维数组的数组名，没有&，没有单独放在sizeof内部 //a就是首元素的地址，即第一行的地址，所以*a就是第一行，计算的是第一行的大小 printf("%dn", sizeof(a[3]));//16 解释：a[3]其实是第四行的数组名（如果有的话） //所以其实不存在，也能通过类型计算大小的 printf("%dn", sizeof(a[-1])); //16 解释：同上

int main() { short s = 5; int a = 4; printf("%dn", sizeof(s = a + 6));//2 算的是short大小 printf("%dn", s);//5 sizeof内部表达式不参与运算 return 0; } 就可以解释上述代码中中的 printf("%dn", sizeof(a[3])); printf("%dn", sizeof(a[-1]));

類10. 指针笔试题

笔试题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() { //0x1 16进制1 printf("%pn", p + 0x1); printf("%pn", (unsigned long)p + 0x1); printf("%pn", (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 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;//int (*)[5] printf("%p,%dn", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]); //? return 0; }

【C语言】指针进阶

C/C++/C#相关栏目本月热门文章