指针的进一步学习-优快云博客

本文链接：https://blog.youkuaiyun.com/pegasus8/article/details/128820906

首先对于数组名的回忆：

1.sizeof（数组名）代表整个数组，单位是字节。

2.&数组名（类型为数组指针），数组名表示整个数组，取出的是整个数组的地址（只要是地址就是4/8个字节）。

其他情况之下，所有的数组名均代表数组首元素的地址。

sizeof得到的类型的size_t即unsigned int类型（无符号整型）。

sizeof计算字符串长度包括末尾隐含的‘/0’。而strlen则是遇到‘/0’才停止计算。

在此之下的所有题目都依据于上述。

关于strlen：

int main()
{
	//字符数组
	char arr[] = { 'a','b','c','d','e','f' };
	//char*
	//char [6]
	printf("%d\n", strlen(arr));//随机值
	printf("%d\n", strlen(arr + 0));//随机值
	//printf("%d\n", strlen(*arr));//strlen('a')->strlen(97),非法访问-err
	//printf("%d\n", strlen(arr[1]));//'b'-98,和上面的代码类似，是非法访问 - err
	printf("%d\n", strlen(&arr));//&arr虽然是数组的地址，但是也是从数组起始位置开始的，计算的还是随机值
	//char(*)[6]
	printf("%d\n", strlen(&arr + 1));
	//&arr是数组的地址，&arr+1是跳过整个数组的地址，求字符串长度也是随机值
	printf("%d\n", strlen(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址，是'b'的地址，求字符串长度也是随机值

	return 0;
}

可以理解为：提供地址，寻找‘/0’，找到为止。

（跳过整个数组时，‘/0’同样会跳过）。

int main()
{
	char arr[] = "abcdef";//数组是7个元素
	//[a b c d e f \0]
	printf("%d\n", strlen(arr));//6,arr是数组首元素的地址，strlen从首元素的地址开始统计\0之前出现的字符个数，是6
	printf("%d\n", strlen(arr + 0));//arr + 0是数组首元素的地址，同第一个，结果是6
	//printf("%d\n", strlen(*arr));//*arr是'a',是97，传给strlen是一个非法的地址，造成非法访问
	//printf("%d\n", strlen(arr[1]));//err
	printf("%d\n", strlen(&arr));//6
	printf("%d\n", strlen(&arr + 1));//&arr + 1是跳过数组后的地址，统计字符串的长度是随机值
	printf("%d\n", strlen(&arr[0] + 1));//&arr[0]+1是b的地址，从第二个字符往后统计字符串的长度，大小是5



	return 0;
}

字符指针变量中存放字符串，该变量指向该字符串的首个字符，解引用后也是首个字符。

例如；char* p="abcd",p指向的是‘a'，而p[0]相当于*p。

int main()
{
	const char* p = "abcdef";
	
	printf("%d\n", strlen(p));//6- 求字符串长度
	printf("%d\n", strlen(p + 1));//p + 1是b的地址，求字符串长度就是5
	//printf("%d\n", strlen(*p));//err，*p是'a'
	//printf("%d\n", strlen(p[0]));//err - 同上一个
	printf("%d\n", strlen(&p));//&p拿到的是p这个指针变量的起始地址，从这里开始求字符串长度完全是随机值
	printf("%d\n", strlen(&p + 1));//&p+1是跳过p变量的地址，从这里开始求字符串长度也是随机值
	printf("%d\n", strlen(&p[0] + 1));//&p[0] + 1是b的地址，从b的地址向后数字符串的长度是5

	printf("%d\n", sizeof(p));//p是指针变量，大小就是4/8字节
	printf("%d\n", sizeof(p + 1));//p + 1是b的地址，是地址，就是4/8个字节
	printf("%d\n", sizeof(*p));//*p是'a'，sizeof(*p)计算的是字符的大小，是1字节
	printf("%d\n", sizeof(p[0]));//p[0]-->*(p+0) --> *p  就同上一个，1字节
	printf("%d\n", sizeof(&p));//&p是二级指针，是指针大小就是4/8
	printf("%d\n", sizeof(&p + 1)); //&p + 1是跳过p变量后的地址，4/8字节
	printf("%d\n", sizeof(&p[0] + 1));//p[0]就是‘a’,&p[0]就是a的地址，+1，就是b的地址，是地址就是4/8

	return 0;
}

p为指针，就是地址。

int main()
{
	//二维数组
	int a[3][4] = { 0 };
	//printf("%p\n", &a[0][0]);
	//printf("%p\n", a[0]+1);


	printf("%d\n", sizeof(a));//48 = 3*4*4
	printf("%d\n", sizeof(a[0][0]));//4
	printf("%d\n", sizeof(a[0]));//a[0]是第一行的数组名，数组名单独放在sizeof内部，计算的就是数组(第一行)的大小，16个字节
	printf("%d\n", sizeof(a[0] + 1));//a[0]作为第一行的数组名，没有单独放在sizeof内部，没有取地址，表示的就是数组首元素的地址
	//那就是a[0][0]的地址，a[0]+1就是第一行第二个元素的地址，是地址就是4/8个字节
	printf("%d\n", sizeof(*(a[0] + 1)));//*(a[0] + 1)是第一行第2个元素，计算的是元素的大小-4个字节
	printf("%d\n", sizeof(a + 1));//a是二维数组的数组名，数组名表示首元素的地址，就是第一行的地址，a+1就是第二行的地址
	//第二行的地址也是地址，是地址就是4/8   
	//a - int (*)[4]
	//a+1--> int(*)[4]
	printf("%d\n", sizeof(*(a + 1)));//a+1是第二行的地址，*(a+1)表示的就是第二行，*(a+1)--a[1]  //16
	printf("%d\n", sizeof(&a[0] + 1));//&a[0]是第一行的地址，&a[0]+1是第二行的地址，地址的大小就是4/8
	printf("%d\n", sizeof(*(&a[0] + 1)));//*(&a[0] + 1) 是对第二行的地址解引用，得到的就是第二行，计算的就是第二行的大小
	printf("%d\n", sizeof(*a));//a表示首元素的地址，就是第一行的地址，*a就是第一行，计算的就是第一行的大小
	//*a -- *(a+0)--a[0]
	printf("%d\n", sizeof(a[3]));//16字节 int[4]
	//如果数组存在第四行，a[3]就是第四行的数组名，数组名单独放在sizeof内部，计算的是第四行的大小

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

	return 0;
}

在二维数组中，a[0]相当于首元素地址，也是数组名。

注：sizeof内是不会发生运算的。

struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}* p;
假设p 的值为0x100000。 如下表表达式的值分别为多少？
已知，结构体Test类型的变量大小是20个字节
int main()
{
	p = (struct Test*)0x100000;
	printf("%p\n", p + 0x1);
	//0x00100014
	printf("%p\n", (unsigned long)p + 0x1);
	//0x00100001
	printf("%p\n", (unsigned int*)p + 0x1);
	//0x00100004
	return 0;
}

三道题目，都将p变为了不同的类型，但p的本质是指针，是地址，所以打印形式不变，但不同的类型的内存不同，所以打印出来的值也不同。（相当于跳过了不同大小的内存）。

一道有趣的笔试题

小端，x86环境
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.

第一问比较简单，第二问的逻辑：

首先将数组的首元素地址强制类型转换为int，之后加一。设想，倘若不进行类型转换的话，+1该跳过4个字节（也就是首个元素），但转换后只能跳过1字节（因为之后又将整个整体转换为int*）