投稿
  1. 首页
  2. C

指针详详姐

code • 2022-4-19 • C • 阅读 51

指针详详姐,第1张

目录
  • 1. 字符指针
  • 2. 指针数组
  • 3. 数组指针
    • 3.1 数组指针的定义
    • 3.2 &数组名VS数组名
    • 3.3 数组指针的使用
  • 4. 数组参数、指针参数
    • 一维数组
    • 二维数组
    • 一级指针传参
    • 二级指针传参
  • 函数指针
  • 函数指针数组
  • 指向函数指针数组的指针
  • 回调函数
  • 指针和数组笔试题解析
  • 指针笔试题

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

  1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。

  2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。

  3. 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用 *** 作的时候的权限。

  4. 指针的运算
1. 字符指针 
int main()
{
	const char* p1 = "abcdef";
	const char* p2 = "abcdef";

	char arr1[] = "abcdef";
	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;
}

这里str3和str4指向的是一个同一个常量字符串。

C/C++会把常量字符串存储到单独的一个内存区域，当
几个指针。

指向同一个字符串的时候，他们实际会指向同一块内存。

但是用相同的常量字符串去初始化
不同的数组的时候就会开辟出不同的内存块。

所以str1和str2不同，str3和str4不同

2. 指针数组
  • 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;
}

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;
}

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

数组指针是指针？还是数组？
答案是：指针。


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

  • int *p1[10];
  • int (*p2)[10];
    p1, p2分别是什么？

解释:

int (*p)[10];

  • 解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。

    所以p是一个
    指针，指向一个数组，叫数组指针。

  • 这里要注意：[]的优先级要高于号的，所以必须加上（）来保证p先和结合
3.2 &数组名VS数组名 
int main()
{
	int a = 10;
	int* p = &a;

	int arr[10] = {0};         // int(*p)arr[10] = &arr;  [10]里面的10不能省略
	//数组是首元素的地址
	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;
}

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

  • 实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。

    （细细体会一下）

  • 本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型

  • 数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40

  • 想一想 char* arr[5], p = &arr 补全p

3.3 数组指针的使用
  • int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  • int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
    • 数组名表示首元素的地址，
    • 在一维数组里面，arr相当于arr[0]指向的是一个元素 1 ，arr+1跳过的是一个元素的大小,指向2
    • 在二维数组里面，arr相当于arr[0]指向的是一个数组 {1,2,3,4,5}，arr+1跳过的是一个数组大小，指向{2，3，4，5，6}，(arr指向一行，也可以叫行指针)
    • 所以上面一维数组传参用整形指针接收（int*p）,二维数组传参用数组指针接受（int(*p)[5]）

一维数组不推荐使用数组指针形式传参
（传参建议都写成指针形式）

形参写成指针的形式（推荐推荐）
void print1(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(arr + 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 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");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	print2(arr, 3, 5);
	return 0;
}


二维数组传参写成指针形式
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} };
	// 数组名arr，表示首元素的地址
	// 但是二维数组的首元素是二维数组的第一行
	// 所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
	// 可以数组指针来接收
	print2(arr, 3, 5);
	return 0;
}

  • int arr[5];
    arr是一个整形数组，每个元素是int类型的，有5个元素

  • int* parr1[10];
    parr1是一个数组，数组10个元素，每个元素的类型是int*

  • int(*parr2)[10];
    parr2是一个指向数组的指针，指向的数组有10个元素，每个元素的类型是int

  • int(* parr3[10])[5];
    parr3 是一个数组，数组有10个元素，每个元素的类型是：int(*)[5]
    parr3是存放数组指针的数组

下面图片表示的是： int(* parr3[10])[5];

4. 数组参数、指针参数 一维数组


二维数组

一级指针传参 
一级指针传参
void test(int* ptr)
{
	//...
}

int main()
{
	int a = 10;
	int* p = &a;
	int arr[10];
	test(arr);//数组
	test(&a);//p是一级指针
	test(p);
	return 0;
}
二级指针传参 
void test(char** ppc)
{
	// ......
}

int main()
{
	char ch = 'a';
	char* pc = &ch;
	char** ppc = &pc;
	char* arr[4];

	//char arr2[3][5];
	//test(arr2);     /// error  要用数组指针  void test（char（*ppc)[5]）
	                  /// void test(char ppc[][5]) 或 void test（char ppc[3][5]）
	test(arr);
	test(&pc);
	test(ppc);
	
	return 0;
}
函数指针

首先看一段代码

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

输出结果

输出的是两个地址，这两个地址是 test 函数的地址。


那我们的函数的地址要想保存起来，怎么保存？
下面我们看代码：

void test()
{
	printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void* pfun2();

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

pfun1可以存放。

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

阅读两段有趣的代码：

解释：

	//代码1
	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);//函数声明

	signal是一个函数的声明
	signal函数的参数，第一个是int类型的，第二个是void(*)(int)的函数指针类型
	signal函数的返回值类型也是：void(*)(int)的函数指针
	
    // 下面的等价于代码2
	typedef void(*pf_t)(int);//给函数指针类型void(*)(int)重新起名叫：pf_t
	pf_t signal(int, pf_t);
	
	// 下面的error
	void(*)(int) signal(int, void(*)(int));//err
函数指针数组

数组是一个存放相同类型数据的存储空间，那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

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;
}


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;
}
指向函数指针数组的指针

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

#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++)
	{
		// pfarr == *p3 == *(p3+0) == p3[0]
		
		// 下面三个等价
		int ret = pfarr[i](3,4);
		int ret = (*p3)[i](3,4);
		int ret = p3[0][i](3, 4);
		printf("%d\n", ret);
	}

	return 0;
}
回调函数

回调函数就是一个通过函数指针调用的函数。

如果你把函数的指针（地址）作为参数传递给另一个
函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。

回调函数不是由该函数
的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进
行响应。

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

#include
#include

// 打印数组
void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
// 比较int函数
int cmp(const void* e1, const void* e2)
{
	return (*(int*)e1 - *(int*)e2);
}

struct Stu
{
	char name[20];
	int age;
	double score;
};
// 比较结构体age比较函数
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++;
	}
}

// 采用冒泡排序实现qsort
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 test1()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	//排序为升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp);
	print_arr(arr, sz);
}

void test2()
{
	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()
{
	test1();
	//test2();
	return 0;
}
指针和数组笔试题解析

数组名是什么呢？
数组名通常来说是数组首元素的地址
但是有2个例外：

  1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小
  2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址
数组名的意义：
	1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。

	2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。

	3. 除此之外所有的数组名都表示首元素的地址。


    一维数组
	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 数组第二个元素的地址

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

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

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

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

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

    和前面的字符数组不同。
字符串末尾包含有‘\]’
	= arr"abcdef"; //[a b c d e f printf] ("%d\n"
	,
	strlen()) ;//6arrprintf("%d\n",
	strlen(+0 ))arr ; //6//printf("%d\n", strlen(*arr));//err//printf("%d\n", strlen(arr[1]));//errprintf(
	"%d\n"
	,
	strlen(&) );//6arrprintf("%d\n",
	strlen(&+ 1))arr ; //随机值printf("%d\n",
	strlen(&[ 0]+arr1)) ; //5printf("%d\n",


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

	printf( p "%d\n" ,strlen

	()); //6printfp("%d\n",strlen
	(+1) );p //5 从b的位置开始向后数字符 //printf("%d\n", strlen(*p));  //err//printf("%d\n", strlen(p[0]));//errprintf("%d\n"
	,
	strlen
	(&)) ;//随机值printfp("%d\n",strlen
	(&+1 ));p //随机值 printf("%d\n",strlen
	(&[0 ]+1p)); //5  从b的位置开始向后数字符 printf("%d\n",sizeof


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

下面的内容要好好看看，很多容易理解错误

	二维数组
	
	4 a]=0};printf ( { "%d\n" ,sizeof

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

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

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

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

	(
	)
	int
指针笔试题

笔试1

[ 5]=
{
	1 a,2, 3 { ,4 ,5 }; int* = (int
	*) ptr ( &+1);printfa ( "%d,%d",*
	(+1) ,*a ( -1) );ptr // 2  5 return0;}  //这里告知结构体的大小是20个字节
	struct Testint
;

笔试2

char
* ;
{
	short Num;
	char[ pcName2
	] sDate;
	short cha[4];
	} sBa*;//已知，结构体Test类型的变量大小是20个字节int
main(p)
//假设p 的值为0x100000。
 如下表表达式的值分别为多少？
/*这里要注意指针加减，代表跳过指针类型个字节*/
printf ("%p\n",
{
	+
	0x1);// 0x100014 p // 20 - 十六进制 14   printf("%p\n" ,
	// p为结构体类型的指针，加（0x1）-->1, 跳过1个结构体大小,即加20个字节
	(
	unsignedlong)+ 0x1) ;;p // 0x100001 // 这里要注意是将p强制转换为一个整数，整数加1，就是加1printf( "%p\n" ,
	(
	unsignedint*) +0x1 );// ; // 0x100004p // p强制转换为整形指针，4个字节  return0; }
	int
	main ()
int

笔试3

[ 4]=
{
1 a,2, 3 { ,4 }; int* = (int
* )ptr1 ( &+ 1);inta * =(int
* )ptr2 ( (int )+1);printfa ( "%x,%x",[
-1 ], ptr1*);return0 ;ptr2}int
main ()
// 这里要注意里面是小括号，逗号表达式


笔试4

//  int a[3][2] = { 1,3,5 }; // 1 3// 5 0// 0 0
{
	int
	// （0，1）-> 1, （2，3）->3, （4，5）->5
	[
    三行两列
	3
	]
	[
	2 a]=(0,1 ) { ,(2 ,3) ,(4 ,5) };int *; =[
	0] p;
	p printf a("%d",[
	0]); p// 1return0;} int
	main ()
int

笔试5

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


笔试6

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

笔试7

* []=
{
	"work", a"at", "alibaba" { };char** =;
	++;printf pa ( a"%s\n"
	pa,*
	);return0 ;pa}int
	main ()
char

笔试题8

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

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/673807.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-04-19
下一篇 2022-04-19

发表评论

登录后才能评论

评论列表（0条）

保存