C语言从入门到实战————数组和指针的深入理解

最新推荐文章于 2024-11-11 20:03:56 发布

向前阿、

最新推荐文章于 2024-11-11 20:03:56 发布

阅读量645

点赞数 18

文章标签： c语言算法程序人生

本文链接：https://blog.csdn.net/2203_75422717/article/details/136684041

版权

本文详细解释了C语言中数组和指针的概念，比较了sizeof和strlen的使用场景，以及在数组和指针操作中的笔试题解析，帮助读者理解数组名、地址计算和内存占用情况。

摘要由CSDN通过智能技术生成

前言

在C语言中，数组和指针有的密切得联系，因为数组名本身就相当于一个指针常量。
指针是一个变量，专门用来存储另一个变量的内存地址，通过这个地址可以访问和操作该变量的值，同时也包括数组。
数组是一组连续存储的同类型数据的集合，它允许通过索引快速访问各个元素。同时数组名也是数组首元素的地址。

1.sizeof和strlen的对比

1.1 sizeof

sizeof是C语言中的单目操作符，用于返回对象或类型所占的内存字节数。如果操作数是类型的化，则计算该变量类型的内存大小。

sizeof 只关注占⽤内存空间的大小，不在乎内存中存放什么数据。

比如：

int main()
{
	int a = 10;
	printf("%d\n", sizeof(a)); //sizeof根据类型计算大小，a为整型，大小为4
	printf("%d\n", sizeof a); //少了括号，结果还是4，目的是想说明sizeof不是函数，仅仅只是一个操作符
	printf("%d\n", sizeof(int)); //给的是整型，结果大小为4
	return 0;
}

1.2 strlen

strlen 是C语⾔库函数，功能是求字符串⻓度。函数原型如下：

size_t strlen ( const char * str );

统计的是从 strlen 函数的参数 str 中这个地址开始向后， \0 之前字符串中字符的个数。 strlen 函数会⼀直向后找 \0 字符，直到找到为⽌，所以可能存在越界查找。

比如：

int main()
{
	char arr1[3] = { 'a', 'b', 'c' };
	char arr2[] = "abc";
	printf("%d\n", strlen(arr1));//数组名不在sizeof后面，所以理解为首元素的地址，往后找'\0'，所以为随机值
	printf("%d\n", strlen(arr2));//3
	printf("%d\n", sizeof(arr1));//arr1为数组名，所以在sizeof后面，计算的是所有元素的大小，大小3
	printf("%d\n", sizeof(arr2));//4
	return 0;
}

sizeof	strlen
1. sizeof是操作符	1. strlen是库函数，使⽤需要包含头⽂件 string.h
2.sizeof计算操作数所占内存的⼤⼩，单位是字节	2. srtlen是求字符串⻓度的，统计的是 \0 之前字符的隔个数
3.不关注内存中存放什么数据	3. 关注内存中是否有 \0 ，如果没有 \0 ，就会持续往后找，可能会越界。

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

2.1 一维数组

int main()
{
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a)); //a为数组名，在sizeof后面求的是整个数组的大小，16
	printf("%d\n", sizeof(a + 0));//a为数组名，但是不是单独出现在sizeof后面，所以是首元素的地址，sizeof求地址的大小，值为4/8
	printf("%d\n", sizeof(*a)); //a为首元素的地址，*a为1，1的类型为int，所以大小为4
	printf("%d\n", sizeof(a + 1));//a为首元素的地址，+1，就是往后位移一个int类型的大小，所以值为4
	printf("%d\n", sizeof(a[1]));//a[1] = *(a+1) = 2 , 所以大小为4
	printf("%d\n", sizeof(&a));//a为数组名，&a取出的是整个数组的地址，而sizeof求地址的大小，所以值为4/8
	printf("%d\n", sizeof(*&a));//*和&相互抵消，a为数组名，单独出现在sizeof后面，计算的是整个数组的大小，所以值为16
	printf("%d\n", sizeof(&a + 1));//&a取出是整个数组的地址，+1后跳过整个数组，本质上还是指针，所以值为4/8
	printf("%d\n", sizeof(&a[0]));//a[0] = *(a+0) = a = &a ,得到的是a的地址，大小为4/8
	printf("%d\n", sizeof(&a[0] + 1));//&a，指向a的地址，也就是首元素的地址，+1后得到第二个元素的地址，大小为4/8
	return 0;
}

2.2 字符数组

代码1

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr)); //arr为数组名，单独出现在sizeof后面，则计算整个数组元素的大小，值为6
	printf("%d\n", sizeof(arr + 0)); //arr为数组名，但并没有单独出现在sizeof后面，所以表示首元素的地址，所以值为4/8
	printf("%d\n", sizeof(*arr)); //arr为数组名，*arr = 'a'，求大小，所以值为1
	printf("%d\n", sizeof(arr[1])); //arr[1] = *(arr + 1) = 'b' , 求大小，所以值为1
	printf("%d\n", sizeof(&arr)); //&arr取出的是整个数组的地址，本质上还是地址，sizeof求地址大小，所以值为4/8
	printf("%d\n", sizeof(&arr + 1));//&arr取出整个数组的地址，+1后跳出整个数组，本质上还是指针，求大小，值为4/8
	printf("%d\n", sizeof(&arr[0] + 1)); //arr[0] = *(arr + 1) = b = &b + 1 = c的地址，本质还是地址，求大小，值为4/8
	return 0;
}

代码2：

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", strlen(arr)); //arr为首元素的地址，数据类型为字符数组，其中并没有'\0'，所以为随机值
	printf("%d\n", strlen(arr + 0)); //arr为首元素的地址，+0，还是一样，值为随机值
	//printf("%d\n", strlen(*arr)); //arr为首元素的地址，*arr = 'a',a的askii码值为97，程序报错
	//printf("%d\n", strlen(arr[1])); //arr[1] = *(arr + 1) = 'b'，程序报错
	printf("%d\n", strlen(&arr)); //&arr取出的是整个数组的地址，和第一个没区别，还是会往后找'\0',值为随机值
	printf("%d\n", strlen(&arr + 1));//&arr取出的是整个数组的地址，+1后跳出数组，值为随机值
	printf("%d\n", strlen(&arr[0] + 1)); //arr[0] = *(arr + 0) = &'a' + 1 的到'b'的地址，结果也为随机值，比第一个小1
	return 0;
}

代码3：

int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr)); //arr单独出现在sizeof后面，表示求的是整个数组的大小，包括'\0',7
	printf("%d\n", sizeof(arr + 0)); //arr并没有单独出现在sizeof后面，所以arr为首元素的地址，sizeof求地址大小，值为4/8
	printf("%d\n", sizeof(*arr)); //arr为首元素的地址，*arr = a ,a为char类型，所以值为1
	printf("%d\n", sizeof(arr[1])); //arr[1] = *(arr+1) = b , b为char类型，所以值为1
	printf("%d\n", sizeof(&arr)); //&arr,取出的是整个数组的地址，本质上还是地址，值为4/8
	printf("%d\n", sizeof(&arr + 1)); //&arr+1，跳出整个数组，本质上还是地址，值为4/8
	printf("%d\n", sizeof(&arr[0] + 1)); //arr[0] = *(arr+0) = &a+1 = b的地址，本质上还是地址，值为4/8 
	return 0;
}

代码4：

int main()
{
	char arr[] = "abcdef";
	printf("%d\n", strlen(arr)); //arr为首元素的地址，strlen就是往后找'\0'，值为6
	printf("%d\n", strlen(arr + 0)); //arr为首元素地址，值为6
	//printf("%d\n", strlen(*arr)); //*arr = a ,a的ascii码值为97，程序崩溃
	//printf("%d\n", strlen(arr[1])); //arr[1] = *(arr + 1) = b , 程序崩溃
	printf("%d\n", strlen(&arr)); //&arr取出的是整个数组的地址，和第一个没区别,值为6
	printf("%d\n", strlen(&arr + 1)); //&arr+1,跳出数组范围，为随机值
	printf("%d\n", strlen(&arr[0] + 1)); //arr[0] = *(arr+0) = &a+1=b的地址，值为5
	return 0;
}

代码5：

int main()
{
	char* p = "abcdef";
	char arr[] = "abcdef";
	printf("%d\n", sizeof(p)); //为指针,4/8
	printf("%d\n", sizeof(p + 1)); //p并没有单独出现在sizeof后面，p为首元素的地址，+1后得到，b的地址，值为4/8
	printf("%d\n", sizeof(*p));  //p为首元素的地址，*p的到a，a为char类型，值为1
	printf("%d\n", sizeof(p[0]));  //p[0] = *(p+0) = a ,值为1
	printf("%d\n", sizeof(&p));  //&p取出的是指针的地址，本质上还是地址，值为4/8
	printf("%d\n", sizeof(&p + 1)); //&p+1，本质上还是地址，值为4/8
	printf("%d\n", sizeof(&p[0] + 1)); //p[0] = *(p+0) = &a+1 = b的地址，本质还是地址，值为4/8
	return 0;
}

代码6：

int main()
{
	char* p = "abcdef";
	printf("%d\n", strlen(p)); //p为指针，首元素的地址，值为6
	printf("%d\n", strlen(p + 1)); //p + 1指向b，则值为5
	//printf("%d\n", strlen(*p));  //*p = a ，ascii码值为97，程序崩溃
	//printf("%d\n", strlen(p[0])); //p[0] = *(p+0) = a,程序崩溃
	printf("%d\n", strlen(&p)); //p为指针，&p为指针的地址，所以为随机值
	printf("%d\n", strlen(&p + 1)); //本质还是地址，所以为随机值
	printf("%d\n", strlen(&p[0] + 1)); //p[0] = *(p+0) = &a + 1 = b的地址，所以值为5
	return 0;
}

2.3 二维数组

int main()
{
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//a为数组名，单独出现在sizeof后面，表示求整个二维数组的大小，所以值为48
	printf("%d\n", sizeof(a[0][0])); //a[0][0] = 0 ,类型为int，所以值为4
	printf("%d\n", sizeof(a[0])); //a[0]为二维数组一行的数组名，单独出现在sizeof后面，求的是第一行数组的大小，16
	printf("%d\n", sizeof(a[0] + 1)); //a[0]为二维数组第一行的数组名，没有单独出现在sizeof后面，则表示首元素的地址，+1得到第二个元素的地址，4/8
	printf("%d\n", sizeof(*(a[0] + 1)));//4
	printf("%d\n", sizeof(a + 1)); //a为数组名，没有单独出现在sizeof后面，所以a为首元素的地址，+1后跳过整个二维数组，本质上还是地址，值为4/8
	printf("%d\n", sizeof(*(a + 1)));//a为数组名，但没有单独出现在sizeof之后，所以为首行的地址，+1后为第一行的地址，解引用得到第一行元素为16
	printf("%d\n", sizeof(&a[0] + 1)); //a[0] = *(a+0) = &0 + 1 = 第零行第一列的地址，值为4/8
	printf("%d\n", sizeof(*(&a[0] + 1)));//对第一行进行解引用，值为16
	printf("%d\n", sizeof(*a)); //a为数组名，并没有单独出现在sizeof后面，所以为首行的地址，解引用后得到第零行的元素，值为16
	printf("%d\n", sizeof(a[3]));//a[3] = *(a + 3) ,首行元素的地址，加三，得到第三行元素的地址，再解引用，得到第四行元素，值为16
	return 0;
}

数组名的意义：

1. sizeof(数组名)，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩

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

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

3.指针运算笔试题解析

3.1 题目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
}

3.2 题目2

//在X86环境下
//假设结构体的⼤⼩是20个字节
//程序输出的结果是啥？
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p = (struct Test*)0x100000;
int main()
{
	printf("%p\n", p + 0x1); //0x100000 + 20 = 00100014 
							 //此处环境为32位，每4位可以用一个十六进制表示，所以，总共是有8个十六进制，所以结果在前面补了两个0
	printf("%p\n", (unsigned long)p + 0x1); //0x100000 + 1 = 00100001
	printf("%p\n", (unsigned int*)p + 0x1); //0x100000 + 4 = 00100004
	return 0;
}

3.3 题目3

int main()
{
	int a[3][2] = { (0, 1), (2, 3), (4, 5) }; // {{1,3}，{5,0}，{0,0}}
                                              // 逗号表达式
	int* p;
	p = a[0];
	printf("%d", p[0]);//1
	return 0;
}

3.4 题目4

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

3.5 题目5

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));// 10 5
	return 0;
}

3.6 题目6

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

3.7 题目7

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