C语言：指针进阶（4）

最新推荐文章于 2024-09-25 23:59:39 发布

IfYouHave

最新推荐文章于 2024-09-25 23:59:39 发布

阅读量151

点赞数

分类专栏： C语言文章标签： c语言 c++ 数据结构

本文链接：https://blog.csdn.net/IfYouHave/article/details/129217377

版权

C语言专栏收录该内容

36 篇文章 0 订阅

订阅专栏

9. 指针和数组笔试题解析

//一维数组

//数组名是什么呢？
//数组名通常来说是数组首元素地址
//但是有两个例外
//1.sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小
//2.&数组名，这里的数组名表示整个数组，取出的是整个数组的地址
int main()
{
	//一维数组
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));//16
	printf("%d\n", sizeof(a + 0));//4/8 — 表示a[0],a+0是数组第一个元素的地址
	printf("%d\n", sizeof(*a));//4 —— a表示首元素的地址，*a第一个元素
	printf("%d\n", sizeof(a + 1));//4/8 —— a+1表示数组第二个元素地址
	printf("%d\n", sizeof(a[1]));//4 —— a[1]表示数组下标为1的元素
	printf("%d\n", sizeof(&a));//4/8 —— 取出的是整个数组的地址,地址的大小为4/8
	printf("%d\n", sizeof(*&a));//16 ——取出的是整个数组的地址，解引用拿到整个数组
	printf("%d\n", sizeof(&a + 1));//4/8 ——取出整个数组的地址，&a+1，跳过16个字节的地址
	printf("%d\n", sizeof(&a[0]));//4/8 ——取出数组首元素的地址
	printf("%d\n", sizeof(&a[0] + 1));//4/8 ——取出数组首元素的地址加一，相当于第二个元素的地址

	return 0;
}

//字符数组

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));//6——计算整个数组地址的大小
	printf("%d\n", sizeof(arr + 0));//4——arr+0相当于首元素地址
	printf("%d\n", sizeof(*arr));//1——数组首元素，是一个字符,大小是一个字节
	printf("%d\n", sizeof(arr[1]));//1——数组第二个元素，大小也是一个字节
	printf("%d\n", sizeof(&arr));//4/8——取出的是整个元素的地址，地址即4/8
	printf("%d\n", sizeof(&arr + 1));//4/8——跳过整个数组，所拿到的地址，4/8
	printf("%d\n", sizeof(&arr[0] + 1));//4/8——取出第一个元素地址加1，相当于第二个元素地址
	

	return 0;
}

//size_t strlen(const char* string)
#include<string.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", strlen(arr));//随机值——因为strlen在计算字符串长度时，是以'\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

	printf("%d\n", strlen(&arr));//随机值—— 取出的是整个数组的地址，传递给strlen还是被认为首元素地址
	printf("%d\n", strlen(&arr + 1));//随机值——跳向整个数组地址后面，往后判断是否有'\0'
	printf("%d\n", strlen(&arr[0] + 1));//随机值—— 指向'b'的地址，往后判断是否又'\0'
	return 0;
}

#include<string.h>
int main()
{
	char arr[] = "abcdef";
	//printf("%d\n", sizeof(arr));//7 ——计算整个数组的大小，包括'\0'
	//printf("%d\n", sizeof(arr + 0));//4/8 ——数组首元素地址
	//printf("%d\n", sizeof(*arr));//1 ——数组首元素类型的大小
	//printf("%d\n", sizeof(arr[1]));//1 ——数组第二个元素'b'的类型的大小
	//printf("%d\n", sizeof(&arr));//4/8 ——取出的是整个数组的地址，地址的大小4/8
	//printf("%d\n", sizeof(&arr + 1));//4/8 ——跳过整个数组后所得到的地址
	//printf("%d\n", sizeof(&arr[0] + 1));//4/8 ——数组第二个元素的地址
	//printf("%d\n", sizeof(*(& arr[0] + 1)));//1——数组第二个元素地址中元素类型的大小

	printf("%d\n", strlen(arr));//6—— 这里arr是数组首元素地址，从数组首元素开始，计算'\0'之前字符的个数
	printf("%d\n", strlen(arr + 0));//6 ——这里arr+0相当于数组首元素地址，同上
	//printf("%d\n", strlen(*arr));//err ——这里*arr相当于数组首元素'a' ——97,会报错
	//printf("%d\n", strlen(arr[1]));//err ——这里arr{b]相当于数组第二个元素'b' ——98,会报错
	printf("%d\n", strlen(&arr));//6 ——这里取出的是整个数组的地址，整个数组的地址的值和数组首元素的地址的值相等
	printf("%d\n", strlen(&arr + 1));//随机值——这里表示跳过整个数组，传递的是整个数组后一个的地址
	printf("%d\n", strlen(&arr[0] + 1));//5——这里相当于数组第二个元素的地址，从第二个元素开始，计算'\0'之前字符的个数

	return 0;
}

sizeof 计算的是对象所占内存的大小————单位是字节

它不在乎内存中存放的是什么，只在乎大小

sizeof 是一个单目操作符——返回类型是 size_t

strlen函数

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

#include<string.h>
int main()
{
	char* p = "abcdef";//这里的p是一个指针变量，"abcdef"是一个字符串常量，因此p存储的是字符串首元素的地址
	printf("%d\n", sizeof(p));//4/8——因为p是指针变量，存放的是首元素地址，地址的大小为4/8
	printf("%d\n", sizeof(p + 1));//4/8
	printf("%d\n", sizeof(*p));//1
	printf("%d\n", sizeof(p[0]));//1
	printf("%d\n", sizeof(&p));//4/8
	printf("%d\n", sizeof(&p + 1));//4/8
	printf("%d\n", sizeof(&p[0] + 1));//4


	printf("%d\n", strlen(p));//6
	printf("%d\n", strlen(p + 1));//5
	//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


	return 0;
}

//二维数组

int main()
{
	//二维数组
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//48 ——计算整个数组大小 3 * 4 * 4
	printf("%d\n", sizeof(a[0][0]));//4 ——第一行第一个元素类型所占空间的大小
	printf("%d\n", sizeof(a[0]));//16 ——计算第一行整个数组大小
	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]

	printf("%d\n", sizeof(&a[0] + 1));//4——a[0]是第一行的数组名，&a[0]就是取出第一行的地址
	//第一行的地址加一就是第二行的地址
	printf("%d\n", sizeof(*(&a[0] + 1)));//16
	printf("%d\n", sizeof(*a));//16

	printf("%d\n", sizeof(a[3]));//16
	//这里会真的去内存中第四行看下占有几个字节？
	//答案是不是，这里a{3]第四行的数组名，跟第三行一样，
	//只要知道一行的数组名，它的类型是确定的，类型是int [4]
	//类型确定，大小就是确定的

	int a = 10;
	printf("%d\n", sizeof(a));//4
	printf("%d\n", sizeof(int));//4
	//实际上sizeof计算a的大小并没有真的去内存检查它占有几个字节
	// 是根据a的类型判断出占有4个字节


	//二维数组的理解
	//1.可以把二维数组想象成一维数组，为一行就是一个一维数组
	return 0;
}

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 5

笔试题2:

//由于还没学习结构体，这里告知结构体的大小是20个字节
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;//0x00100000 32位机器下占4给字节，故高位补零
	printf("%p\n", p + 0x1);//结构体指针+1相当于跳过结构体==>+sizoef（结构体），20的十六进制为14	 
	printf("%p\n", (unsigned long)p + 0x1);//这里强转变为整数了，整数+1
	printf("%p\n", (unsigned int*)p + 0x1);//这里加一跳过一个字节
	return 0;
}
//00100014
//00100001
//00100004

笔试题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;
}
//ptr[-1] <===> *(ptr-1) //打印 4
//ptr2 <===> 相当于数组首元素地址转换为int类型 + 1，
// 在转换为int*，相当于数组首元素地址向后跳过一个字节
//故解引用向后访问四个字节, 小端存储模式下
// 01 00 00 00 02 00 00 00 
//  00 00 00 02 因为是小端存储，拿出来需要还原
// 故还原为 02 00 00 00
// 故打印结果为2 00 00 00
//%x 打印形式是无符号的16进制整数

笔试题4:

int main()
{
    int a[3][2] = { (0, 1), (2, 3), (4, 5) };
    //这里是逗号表达式
    int* p;
    p = a[0];
    printf("%d", p[0]);
    return 0;
}
//这里a[0]表示第一行元素的数组名的地址
//p[0] <===> *(p+0) ,相当于访问第一行第一个元素a[0][0] = 1;
//打印结果为一

笔试题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;
}
//p是一个数组指针，指向一个int类型，大小为4的数组,最开始指向数组首元素
// p + 1 相当于数组指针p向后跳过4个整形元素所指向的地址
//p[4][2] <===>*(*(p+4)+2)
//-4 -4
//0xff ff ff fc
//-4

笔试题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;
}
//*(ptr1-1) <====> aa[1][4] //打印10
//*(aa+1) <====> aa[1]
//*(ptr2-1) <====>aa[0][4]  = 5

笔试题7:

//int main()
//{
//	char* a[] = { "work","at","alibaba" };//指针数组
//	char** pa = a;//二级指针指向指针数组首元素地址
//	pa++;//指针数组第二行的地址
//	printf("%s\n", *pa);//at
//	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);//++优先级高，*(cp+1) <==> cp[1] 
	//*(cp[1]) <===> *(c+2) <===> c[2]  //POINT
	printf("%s\n", *-- * ++cpp + 3);//\ER
	//
	printf("%s\n", *cpp[-2] + 3);//ST
	//cpp[-2] <===> *(cpp - 2)   
	printf("%s\n", cpp[-1][-1] + 1);//EW
	// *(*(cpp-1)-1) <====>cpp[-1][-1]
	return 0;
}