突破•指针六

已于 2024-08-09 15:21:00 修改
阅读量621 收藏 18
点赞数 17
分类专栏： # C•干货 文章标签： 算法 数据结构 学习 c语言
于 2024-08-09 02:05:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80766171/article/details/140887722
版权

听说这是目录哦

数组和指针笔试题解析🫧

sizeof关注类型，strlen关注内容。

一维数组

1🍕🍕🍕🍕🍕🍕🍕

🍕题：问运行结果是什么

#include <stdio.h>
int main()
{
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(a + 0));
	printf("%d\n", sizeof(*a));
	printf("%d\n", sizeof(a + 1));
	printf("%d\n", sizeof(a[1]));
	printf("%d\n", sizeof(&a));
	printf("%d\n", sizeof(*&a));
	printf("%d\n", sizeof(&a + 1));
	printf("%d\n", sizeof(&a[0]));
	printf("%d\n", sizeof(&a[0] + 1));
	return 0;
}

答案与解析（看注释）：

#include <stdio.h>
int main()
{
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));//规定sizeof(数组名)计算的是整个数组的大小，而 &数组名 取出的是整个数组的地址，其余情况的数组名都是首元素的地址，一个int型4个字节，答案是4*4=16。
	printf("%d\n", sizeof(a + 0));//这里的a是数组首地址，首地址加0还是首地址，地址都是4或8字节【x86下是4个字节，x64下是8个字节】，（实际sizeof并不会计算括号内的表达式，它只是推断出表达式结果的类型，根据类型和个数得出结果），这里的答案是4或8。
	printf("%d\n", sizeof(*a));//这里的a是首地址，解引用后就是首元素，答案是4。
	printf("%d\n", sizeof(a + 1));//首元素的地址加1就是第二个元素的地址，地址都是4或8【地址都是同样长度的一串字母和数字】，答案是4或8。
	printf("%d\n", sizeof(a[1]));//第二个元素，一个int型的元素，答案是4。
	printf("%d\n", sizeof(&a));//整个数组的地址，是地址，答案是4或8。
	printf("%d\n", sizeof(*&a));//两种解释，第一种是*和&抵消了，最终是sizeof(a)。第二种是&a取出的是整个数组的地址，用*把地址解引用后就是整个数组了。答案是16。
	printf("%d\n", sizeof(&a + 1));//整个数组的地址加1，跳过整个数组的地址，最终还是地址，答案是4或8。
	printf("%d\n", sizeof(&a[0]));//第一个元素的地址，答案是4或8。
	printf("%d\n", sizeof(&a[0] + 1));//第一个元素的地址加1，跳过一个元素，第二个元素的地址，答案是4或8。
	return 0;
}

字符数组

1🍔🍔🍔🍔🍔🍔🍔

🍔题：问运行结果是什么

#include <stdio.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d\n", sizeof(&arr[0] + 1));
	return 0;
}

答案与解析（看注释）：

#include <stdio.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));//计算整个数组的大小，6个字符，答案是6
	printf("%d\n", sizeof(arr + 0));//首元素地址加0，还是首元素地址，答案是4或8
	printf("%d\n", sizeof(*arr));//首元素地址解引用后是首元素，1个char型的数据，答案是1
	printf("%d\n", sizeof(arr[1]));//第二个元素，答案是1
	printf("%d\n", sizeof(&arr));//整个数组的地址，答案是4或8
	printf("%d\n", sizeof(&arr + 1));//跳过整个数组后的地址，答案是4或8
	printf("%d\n", sizeof(&arr[0] + 1));//跳过第一个元素后的地址，即第二个元素的地址，答案是4或8
	return 0;
}

2🌭🌭🌭🌭🌭🌭🌭

🌭题：问运行结果是什么

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr + 1));
	printf("%d\n", strlen(&arr[0] + 1));
	return 0;
}

答案与解析（看注释）：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", strlen(arr));//arr是首元素的地址，从首元素开始向后数，没有\0，停不下来，答案是随机值，不同平台的结果不同
	printf("%d\n", strlen(arr + 0));//首元素加0还是首元素的地址，从首元素开始向后数，没有\0，停不下来，答案是随机值，不同平台的结果不同
	printf("%d\n", strlen(*arr));//解引用首元素地址后即首元素，括号中应该写地址，所以这个代码是错的
	printf("%d\n", strlen(arr[1]));//第二个元素，括号中应该写地址，所以这个代码是错的
	printf("%d\n", strlen(&arr));//整个数组的地址【&arr的类型是char (*)[6]，会被强制转换成char*类型，因为strlen是size_t strlen(const char* s)】的值与首元素地址相同，从首元素开始向后数，没有\0，停不下来，答案是随机值，不同平台的结果不同
	printf("%d\n", strlen(&arr + 1));//跳过整个数组后的地址，从此处往后数，没有\0，停不下来，答案是随机值，不同平台的结果不同
	printf("%d\n", strlen(&arr[0] + 1));//跳过首元素后的地址，即第二个元素的地址，从此处往后数，没有\0，停不下来，答案是随机值，不同平台的结果不同
	return 0;
}

3🍜🍜🍜🍜🍜🍜🍜

🍜题：问运行结果是什么

#include <stdio.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d\n", sizeof(&arr[0] + 1));
	return 0;
}

答案与解析（看注释）：

#include <stdio.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));//计算整个数组的大小，字符串末尾有\0，答案是6+1=7
	printf("%d\n", sizeof(arr + 0));//首元素地址加1还是首元素地址，答案是4或8
	printf("%d\n", sizeof(*arr));//首元素解引用后是首元素，答案是1
	printf("%d\n", sizeof(arr[1]));//第二个元素，答案是1
	printf("%d\n", sizeof(&arr));//整个数组的地址，答案是4或8
	printf("%d\n", sizeof(&arr + 1));//跳过整个数组后的地址，答案是4或8
	printf("%d\n", sizeof(&arr[0] + 1));//跳过首元素后的地址，即第二个元素的地址，答案是4或8
	return 0;
}

4🌮🌮🌮🌮🌮🌮🌮

🌮 题：问运行结果是什么

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr + 1));
	printf("%d\n", strlen(&arr[0] + 1));
	return 0;
}

答案与解析（看注释）：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", strlen(arr));//从首元素开始数，字符串末尾有\0，数到\0前面的停止，答案是6
	printf("%d\n", strlen(arr + 0));//还是首元素地址，答案是6
	printf("%d\n", strlen(*arr));//传的是首元素，会报错，应该传地址
	printf("%d\n", strlen(arr[1]));//传的是第二个元素，会报错
	printf("%d\n", strlen(&arr));//整个数组的地址，与数组首元素的地址相同【&arr的类型是char(*)[7]，会被强制类型转换成char*类型】，即从首元素开始数，字符串末尾有\0，数到\0前面的停止，答案是6
	printf("%d\n", strlen(&arr + 1));//跳过整个数组后的地址，注意\0属于数组内的，即后面没有\0了，答案是随机值
	printf("%d\n", strlen(&arr[0] + 1));//从第二个元素开始数，字符串末尾有\0，数到\0前面的停止，答案是5
	return 0;
}

5🍢🍢🍢🍢🍢🍢🍢

🍢题：问运行结果是什么

#include <stdio.h>
int main()
{
	const char* p = "abcdef";
	printf("%d\n", sizeof(p));
	printf("%d\n", sizeof(p + 1));
	printf("%d\n", sizeof(*p));
	printf("%d\n", sizeof(p[0]));
	printf("%d\n", sizeof(&p));
	printf("%d\n", sizeof(&p + 1));
	printf("%d\n", sizeof(&p[0] + 1));
	return 0;
}

答案与解析（看注释）：

#include <stdio.h>
int main()
{
	const char* p = "abcdef";
	printf("%d\n", sizeof(p));//p是指针，是字符串首字符a的地址，答案4或8
	printf("%d\n", sizeof(p + 1));//p+1是b的地址，答案是4或8
	printf("%d\n", sizeof(*p));//p的类型是const char*，*P的类型就是char*，答案是1个字节
	printf("%d\n", sizeof(p[0]));//可以把常量字符串看成数组，即p[0]是首字符a，也可以理解成p[0] == *(p+0) == *p == 'a'，答案是1
	printf("%d\n", sizeof(&p));//p本来就是地址，再把p的地址取出来，相当于二级指针，即&p的类型是char**，地址都是4或8，答案是4或8
	printf("%d\n", sizeof(&p + 1));// 跳过p指针变量一个char*大小之后的地址，答案是4或8
	printf("%d\n", sizeof(&p[0] + 1));//首字符地址再跳过一个char*大小的字节，即b的地址，答案是4或8
	return 0;
}

6🥟🥟🥟🥟🥟🥟🥟

🥟题：问运行结果是什么

#include <stdio.h>
#include <string.h>
int main()
{
	char* p = "abcdef";
	printf("%d\n", strlen(p));
	printf("%d\n", strlen(p + 1));
	printf("%d\n", strlen(*p));
	printf("%d\n", strlen(p[0]));
	printf("%d\n", strlen(&p));
	printf("%d\n", strlen(&p + 1));
	printf("%d\n", strlen(&p[0] + 1));
	return 0;
}

答案与解析（看注释）：

#include <stdio.h>
#include <string.h>
int main()
{
	char* p = "abcdef";
	printf("%d\n", strlen(p));//a的地址向后数，答案是6
	printf("%d\n", strlen(p + 1));//b的地址向后数，答案是5
	printf("%d\n", strlen(*p));//字符a，会报错
	printf("%d\n", strlen(p[0]));//一样，字符a，会报错
	printf("%d\n", strlen(&p));//从p这个指针变量的起始位置开始向后数，p的地址是一块空间，字符串"abcdef"的地址是另一块空间，p的地址未知，也不知道有没有\0，答案是随机值
	printf("%d\n", strlen(&p + 1));//跳过p的地址后延续的地址，往后数不知道有没有\0，答案是随机值
	printf("%d\n", strlen(&p[0] + 1));//&p[0]是a的地址，+1后是b的地址，向后数，答案是5
	return 0;
}

在这里插入图片描述

二维数组

数组名的意义：

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

1🧋🧋🧋🧋🧋🧋🧋

🧋题：问运行结果是什么

#include <stdio.h>
int main()
{
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(a[0][0]));
	printf("%d\n", sizeof(a[0]));
	printf("%d\n", sizeof(a[0] + 1));
	printf("%d\n", sizeof(*(a[0] + 1)));
	printf("%d\n", sizeof(a + 1));
	printf("%d\n", sizeof(*(a + 1)));
	printf("%d\n", sizeof(&a[0] + 1));
	printf("%d\n", sizeof(*(&a[0] + 1)));
	printf("%d\n", sizeof(*a));
	printf("%d\n", sizeof(a[3]));
	return 0;
}

答案与解析（看注释）：
可以看作数组名的，单独放在sizeof内就是计算整个的大小。

#include <stdio.h>
int main()
{
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//数组名a单独放在sizeof里，计算整个数组的大小，答案是3*4*4=48
	printf("%d\n", sizeof(a[0][0]));//第一行第一个元素，答案是4
	printf("%d\n", sizeof(a[0]));//第一行的数组名单独放在sizeof里，计算第一行的总大小，答案是4*4=16
	printf("%d\n", sizeof(a[0] + 1));//a[0]没有单独放在sizeof里，所以这里的a[0]其实是第一行a[0]的首元素地址，即&a[0][0]，+1就是&a[0][1]，答案是4或8
	printf("%d\n", sizeof(*(a[0] + 1)));//*(a[0] + 1)是第一行的第二个元素，答案是4
	printf("%d\n", sizeof(a + 1));//这里的a是二维数组a的首元素地址，即第一行地址，a+1跳过一行，是第二个行的地址，二维数组的每个元素是一行，a+1是数组指针，答案是4或8
	printf("%d\n", sizeof(*(a + 1)));//第二行元素，答案是4*4=16
	printf("%d\n", sizeof(&a[0] + 1));//&a[0]是第一行的地址，+1后是第二行的地址，答案是4或8
	printf("%d\n", sizeof(*(&a[0] + 1)));//第二行的元素，答案是4*4=16
	printf("%d\n", sizeof(*a));//a是二维数组首元素地址，a是第一行的地址，*a是第一行元素，答案是4*4=16
	printf("%d\n", sizeof(a[3]));//可以通过类型推断出长度，a[3]无需真实存在，a[3]是第四行的数组名，单独放在sizeof里，计算第四行的大小，答案是4*4=16
	return 0;
}

指针运算笔试题解析🫧

1🍒🍒🍒🍒🍒🍒🍒

🍒题：问运行结果是什么

#include <stdio.h>
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int *)(&a + 1);
printf( "%d,%d", *(a + 1), *(ptr - 1));
return 0;
}

答案与解析（看注释）：

#include <stdio.h>
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int *)(&a + 1);
printf( "%d,%d", *(a + 1), *(ptr - 1));//a是首元素的地址，+1后就是第二个元素的地址，即2。&a取出的是整个数组的地址，+1就是跳过整个数组后的地址【在5后面】，再-1回到5。答案是2，5
return 0;
}

2🍉🍉🍉🍉🍉🍉🍉

🍉题：问运行结果是什么

#include <stdio.h>
//在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);
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
	return 0;
}

答案与解析（看注释）：

#include <stdio.h>
//在X86环境下
//假设结构体的大小是20个字节
//程序输出的结果是啥？
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p = (struct Test*)0x100000;//0x100000默认为int型，强制转换为struct Test*型
int main()
{
	printf("%p\n", p + 0x1);//0x1其实就是1，即p+1，+1就是跳过一个p大小的空间，答案是0x100000+20=00100014【1*16¹+4*16⁰=20】
	printf("%p\n", (unsigned long)p + 0x1);//整型相加直接加，答案是0x100000+1=0x100001，打印出来是00100001
	printf("%p\n", (unsigned int*)p + 0x1);//一个unsigned int*是4个字节，答案是0x100000+4=0x100004，打印出来是00100004【在32位环境下用%p打印前面要补够两个0才变成8个16进制位】
	return 0;
}

运行截图：
在这里插入图片描述

3🥝🥝🥝🥝🥝🥝🥝

🥝题：问运行结果是什么

#include <stdio.h>
int main()
{
	int a[3][2] = { (0, 1), (2, 3), (4, 5) };
	int* p;
	p = a[0];
	printf("%d", p[0]);
	return 0;
}

答案与解析（看注释）：

#include <stdio.h>
int main()
{
	int a[3][2] = { (0, 1), (2, 3), (4, 5) };//初始化应用{}，所以这里是逗号表达式，结果是最后一个表达式的结果，即a[3][2] = { 1, 3, 5 }，即 a[3][2] = { (1, 3), (5, 0), (0, 0) }
	int* p;
	p = a[0];//a[0]是第一行的数组名，这里不是前面讲的那两种特殊情况，则这里的a[0]是第一行的首元素，即&a[0][0]
	printf("%d", p[0]);//p[0] == *(p+0) == *p，即 1
	return 0;
}

在这里插入图片描述
运行截图：
在这里插入图片描述

4🥥🥥🥥🥥🥥🥥🥥

🥥题：问运行结果是什么

//假设环境是x86环境，程序输出的结果是啥？
#include <stdio.h>
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;
}

答案与解析（看注释）：

//假设环境是x86环境，程序输出的结果是啥？
#include <stdio.h>
int main()
{+
	int a[5][5];
	int(*p)[4];
	p = a;//把a的地址赋值给p
	printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);//p只是指向和a一样的初始地址，但p有自己的类型int (*)[4]，所以p[4][2]跳过4个整型和2个字节。a[4][2]跳过5个整型和5个字节。%p是十六进制打印地址，直接把补码转成地址形式。%d打印有符号整型，要把补码转成原码再打印。指针减指针后的绝对值是指针之间的元素个数。
	return 0;
}

在这里插入图片描述
运行截图：
在这里插入图片描述

5🍓🍓🍓🍓🍓🍓🍓

🍓题：问运行结果是什么

#include <stdio.h>
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;
}

答案与解析（看注释）：

#include <stdio.h>
int main()
{
	int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int* ptr1 = (int*)(&aa + 1);//&aa取出整个数组的地址，+1跳过整个数组，由int (*)[2][5]类型强制转为int (*)
	int* ptr2 = (int*)(*(aa + 1));//这里的aa是aa的首元素地址，即第一行aa[0]，+1后跳过一行，就是第二行首元素的地址，即aa[1][0]==6，本来就是int (*)，所以这里的强制转换是迷惑人的
	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));//ptr1和ptr2的类型都是int (*)类型，指针跳过几个字节由指针的类型决定
	return 0;
}

在这里插入图片描述
运行截图：
在这里插入图片描述

6🥑🥑🥑🥑🥑🥑🥑

🥑题：问运行结果是什么

#include <stdio.h>
int main()
{
char *a[] = {"work","at","alibaba"};
char**pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}

答案与解析（看注释）：

#include <stdio.h>
int main()
{
	char* a[] = { "work","at","alibaba" };//a是一个指针数组，里面存放的是指针,字符串存的是首字符的地址，分别是w,a,a
	char** pa = a;//a是首元素的地址，指向"work"
	pa++;
	printf("%s\n", *pa);//%s打印字符串，从这个地址向后打印直到\0
	return 0;
}

在这里插入图片描述
运行截图：
在这里插入图片描述

7🍊🍊🍊🍊🍊🍊🍊

🍊题：问运行结果是什么

#include <stdio.h>
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;
}

答案与解析（看注释）：

#include <stdio.h>
int main()
{
	char* c[] = { "ENTER","NEW","POINT","FIRST" };
	char** cp[] = { c + 3,c + 2,c + 1,c };
	char*** cpp = cp;//二级指针里存放的是一级指针的地址
	printf("%s\n", **++cpp);//先++，再*，再*。cpp指向c+3的地址，++后来到c+2，*(c+2)后得到P的地址，再*后就是%S向后打印出POINT
	printf("%s\n", *-- * ++cpp + 3);//加法的优先级最低。上一个printf时，cpp以及变成了c+2，现在再++就变成c+1了，*后得到c+1【二级指针里存放的是一级指针的地址，解引用得到存放的内容】，c+1被--后得到c【是cp[2]的内容变成了c，不是变成了cp[3]】，解引用得到c的内容，即字符串ENTER的首字符地址，即E的地址，再+3后就得到第二个E的地址，向后打印ER
	printf("%s\n", *cpp[-2] + 3);//*cpp[-2]+3 == **(cpp-2)+3，cpp本来指向了cp[2]，-2后指向cp[0]，**(cpp-2)+3 == *cp[0]+3 == F地址+3 == S地址，向后打印ST
	printf("%s\n", cpp[-1][-1] + 1);//cpp还是cp[2]，因为只有++和--会改变cpp，上面的cpp[-2]不会。cpp[-1][-1]+1 == *(*(cpp-1)+1) == *(c+2 - 1)+1 == *(c+1)+1 == NEW中N的地址+1 == NEW中E的地址，向后打印EW
	return 0;	
}

在这里插入图片描述

💗💗💗

在这里插入图片描述

💗💗💗

在这里插入图片描述
运行截图：
在这里插入图片描述

能量站😚

当你弱小的时候，连愤怒都像在撒娇。
请添加图片描述

❤️❤️❤️ 恭喜! 恭喜! 闯关成功! ❤️❤️❤️

浩浩kids
关注
专栏目录
笔试-双指针算法突破
NickDeCodes的博客
04-19 175
双指针技术是一种常用的算法技术，用于解决数组或链表中的问题，通常能以较低的时间复杂度解决问题。双指针可以被分为几种类型，包括等。这里，我将解释这些类型并提供一些示例问题及其解决方案。
突破•指针三
2301_80766171的博客
07-30 699
🫧🫧🫧世界上的每个人都有其特质，只有这些特质得到承认，才能产生作为人的存在感。也不可以省略，因为计算机会计算出这个数组的元素个数，它的具体类型是确定的。，那么二维数组传参，形参的部分可以写成数组，也可以写成指针形式。需要注意的是上述代码不是真是二维数组，因为它的每一行不是连续的。函数指针变量是用来存放函数地址的，将来可以通过地址调用这个函数。结合，表示它是一个指针变量，这个指针变量指向的是具体类型为。❤️❤️❤️ 恭喜!数组指针变量是存放数组的地址，能够指向数组的。
突破•指针二
2301_80766171的博客
07-22 950
🫧🫧🫧发现&arr[0]和&arr[0]+1相差4个字节，arr和arr+1 相差4个字节，因为&arr[0] 和 arr 都是首元素的地址，+1就是跳过一个元素。实参传递给形参的时候，形参会单独创建一份临时空间来接收实参，对形参的修改不影响实参。但是&arr 和 &arr+1相差40个字节，这就是因为&arr是数组的地址，+1 操作是跳过整个数组的。可以把这一级级指针看成是抽屉，里面放着钥匙🗝️，解引用就是拿到钥匙开锁🔓的过程。，即一维数组传参，形参的部分可以写成数组的形式，可以写成指针的形式。
突破•指针一
2301_80766171的博客
07-15 689
🫧🫧🫧对地址进行加减时，指针变量的类型决定你可以操作几个字节以及你每次可以跳过几个字节，即指针的类型决定了指针向前或者向后走一步有多大（距离）。没有指针+指针，类比两个日期相加没有意义，2024年2月16日 加 2024年2月6日 的结果没意义。针），这种类型的指针可以用来接受任意类型地址。类比日期的减法，如2024年2月16日 减 2024年2月6日 的结果是10天，差值是10。❤️❤️❤️ 恭喜!指针变量本身是地址，指针指向的内容是解引用后的。指针是可以比较大小的，数组的下标越大，地址越高。
突破•指针四
2301_80766171的博客
07-30 415
🫧🫧🫧在大多数领域，天赋被高估了，时间长了，决心就是你的天赋。❤️❤️❤️ 恭喜!（俄罗斯套娃，被套着的那个娃就是回调函数。回调函数就是一个通过函数指针调用的函数。函数指针数组是存放函数地址的数组，例如。个函数地址【元素】的数组，每个元素都是。的形参是函数指针，用来接收回调函数。例子：计算器的一般实现。
C语言突破进阶-指针进阶
Allen9012的博客
01-20 1129
C语言突破进阶-指针进阶0. Intro1. 字符指针1.1 字符串的首地址1.2 练习题(from 剑指offer)2. 指针数组2.0 回忆指针数组是什么2.1 指针数组的定义和打印方式3. 数组指针3.1 数组指针的定义3.2 &数组名VS数组名3.3 使用数组指针3.4 数组指针的加减4. 数组参数、指针参数4.1 一维数组传参4.2 二维数组传参4.3 一级指针传参4.4 二级指针传参5. 函数指针5.1 函数有地址5.2 书写函数指针5.3 使用函数指针5.4 阅读两段有趣的代码5.5
C语言指针突破
m0_37407587的博客
09-30 351
指针的基本概念 "&"的使用 "*"的使用 指针变量的申明 指针变量的初始化 指针键 指针的表达式 指针指向的变量参与运算 指针值与整数进行运算 指针使用快捷运算符 指针使用关系运算符 指针的递增与比例因子 指针与数组 指针与字符串 指针数组 指向函数的指针 指针类型的兼容性与类型转换 指针与结构体指针
突破C难点指针
m0_67568972的博客
05-20 365
种一棵树最好的时间是十年前，其次是现在。 大家好这里是笨鸟先飞，最近新学了指针的知识， 为大家带来一篇指针博客的详解。 本篇博客偏基础，适合初学者。 文章目录前言指针是什么？指针和指针类型指针的解引用野指针原因1.局部变量未初始化2.指针越界访问3. 指针指向的空间释放如何避免野指针指针运算指针+-整数指针-指针指针的关系运算指针和数组二级指针指针数组结语 前言 在C语言中，指针...
快速突破 基类，派生类指针
daydr的博客
12-11 645
派生类是基类的变种。所以基类指针引用派生类是安全的。当基类指针指向派生类的对象的时候，只能引用基类成员。如果像引用派生类中的特有成员，则必须把基类指针转化成派生类指针。 ...
C语言重点突破之指针进阶
sclwc的博客
02-26 131
内含C语言四则运算的计算机实现，快来看！
如何通过指针突破C++类的访问权限
08-25
"通过指针突破C++类的访问权限" 在C++编程中，访问权限是非常重要的，通常情况下，我们使用public、private和protected三个访问修饰符来控制类成员的访问权限。其中，private修饰符限定了成员变量或成员函数只能在...
指针 突破 (转载他人，是指针解说的精华)
07-19
《指针突破：C语言指针详解》 在深入探讨UCOS II操作系统时，掌握指针的精髓至关重要，因为指针在系统级编程中扮演着核心角色。本文将通过刘值攻的笔记，全面解析C语言中的指针，帮助读者理解和运用这一关键概念。 ...
LeetCode-12. 整数转罗马数字【哈希表 数学 字符串】
zik的博客
10-08 815
如果该值以 4 或 9 开头，使用 减法形式，表示从以下符号中减去一个符号，例如 4 是 5 (V) 减 1 (I): IV ，9 是 10 (X) 减 1 (I)：IX。仅使用以下减法形式：4 (IV)，9 (IX)，40 (XL)，90 (XC)，400 (CD) 和 900 (CM)。你不能多次附加 5 (V)，50 (L) 或 500 (D)。如果该值不是以 4 或 9 开头，请选择可以从输入中减去的最大值的符号，将该符号附加到结果，减去其值，然后将其余部分转换为罗马数字。
二叉树系列 10/11
最新发布
2301_78191305的博客
10-11 406
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 1001
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
成绩分析报告中的统计指标算法
weixin_58444518的博客
10-08 811
考生总分大于等于满分乘以优秀率，该考生成绩即为优秀，良好、及格和不及格与优秀等级处理方式相同，低分指考生总分小于等于满分乘以低分率，该考生成绩为低分。成绩分析报告中涉及到很多统计指标，包括满分、平均分、最高分、最低分、得分率、难度、区分度、标准差、标准分、信度等，下面将概念较复杂的指标进行简单说明。其中R为信度系数，K为整份试卷的题目数，Si×Si为所有考生在第i题得分的方差，S×S为所有考生所得总分的方差。表示全体考生分数的均值，S表示考生分数的标准差，Z为某考生分数对应的标准分数。
无人机航拍视频帧处理与图像拼接算法
mingo_敏
10-08 357
无人机航拍视频帧处理与图像拼接算法。
力扣 前缀和
嫌人闲事
10-10 455
找子数组的个数了解前缀和的基础。
生成哈夫曼树
TTz012的博客
10-08 314
例如：由叶子节点：5 15 40 30 10，生成的最优二叉树如下图所示，该树的最短带权路径长度为：40 * 1 + 30 * 2 + 5 * 4 + 10 * 4 = 205。所谓树的带权路径长度，就是树中所有的叶节点的权值乘上其到根节点的路径长度（若根节点为 0 层，叶节点到根节点的路径长度为叶节点的层数）二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。
深入解析C语言指针：突破难点，驾驭指针
"这篇文章主要探讨了指针在C语言中的重要性和常见误解，旨在帮助有经验的C程序员深化对指针的理解。作者通过十个主题展开讨论，包括但不限于指针的本质、数组与指针的关系以及如何正确理解和使用指针。文章特别强调...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值