C语言进阶之笔试题详解(1)

最新推荐文章于 2024-08-31 22:19:14 发布
最新推荐文章于 2024-08-31 22:19:14 发布
阅读量2.5k 收藏 132
点赞数 126
分类专栏： C语言进阶 文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79491024/article/details/134588094
版权

引言：

对指针知识进行简单的回顾，然后再完成笔试题。

158c3f50b199454985017a51dbef9841.png               ✨ 猪巴戒：个人主页✨

               所属专栏：《C语言进阶》

        🎈跟着猪巴戒，一起学习C语言🎈

目录

引言：

知识简单回顾

指针是什么

指针变量的大小？

指针类型的意义

指针的运算

指针数组

数组名是什么

数组指针

函数指针

函数指针数组

回调函数 

笔试题

一维数组

题目：

解析：

总结：

字符数组

题目1：

解析：

题目2：

解析：

 总结：

题目3：

解析：

总结：

题目4：

解析：

总结：

题目5：

答案：

题目6：

答案：

知识简单回顾

指针是什么

内存 ->内存的单元（1byte）->编号->地址

我们有一块很大的内存空间，内存空间被分为一个一个的单元，一个内存单元的大小是1byte(字节)，每个字节都有它的编号，这个编号就是地址，地址又叫做指针。

指针就是一个地址。

我们口头语说的指针一般指：指针变量

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

&a就是内存的编号，也是地址.
这个指针变量叫做pa,int*是类型（整形指针），通过这个类型创造的变量叫做pa。

*pa就是对pa进行解引用，通过pa存放的地址找到它所指向的对象（a）,pa存的是a的地址所以pa指向a,*pa其实就是a。

*pa = 20；就相当于 a = 20；将 a 的值改变了。

int main()
{
    int a = 0;

    int* pa = &a;

    *pa = 20;

    return 0;
}

指针变量的大小？

——4/8个字节，取决于编译器是x86环境还是x64环境

指针类型的意义

两件事情：

1.指针类型进行+1/-1的操作时，它会跳过几个字节。

2.进行解引用操作的时候，决定了解引用操作时候的权限，（访问多少个字节）

指针的运算

1。+-整数

2.指针-指针

3.指针的关系运算

指针数组

本质上就是数组，数组中存放的是指针（地址）。

arr 存放了三个元素，每个元素都是int*类型，也就是指针，那么arr就是指针数组。

int main()
{
    int *pa;
    int *pb;
    int *pc;
    int* arr = { pa,pb,pc };
    return 0;
}

0c3c5e59992d496b988dad0d0c445584.png

数组名是什么

1.数组名在大部分情况下表示数组首元素的地址，

但是有两个例外：

a）sizeof（数组名），表示的是整个数组的大小

b）&数组名，取出的是整个数组的地址

数组指针

&数组名，这里的parr ,存放的是数组的地址，parr为数组指针。

数组指针：int (*parr)[10]，parr与*结合，代表parr为指针，[10]表示parr指向数组，数组中元素的类型是int。

指针数组：int* parr[10],没有括号，parr与[10]结合，表示parr为数组，数组中元素的类型是int*(整形指针)

数组指针类型的表示：int (*)[10];

int arr[10] = {1,2,3};
int (*parr)[10] = &arr;

函数指针

函数指针就是函数的地址，函数也有地址，我们可以通过函数的地址去使用函数。

函数的地址存放在函数指针变量中，

函数指针类型表示：

int (*)(int,int)

int (*pf)(int ,int)，pf与*结合，表示pf是指针，指针指向的是(int , int)参数是两个整形的函数，函数的返回类型是int。

int Add(int x,int y)
{
    return x + y;
}

int main()
{
    int (*pf)(int ,int) = &Add;
    int sum = (*pf)(2,3);
    //Add 和 &函数名一样，Add也可以直接表示为地址,因此也可以写成这种形式
    //int (*pf)(int ,int) = Add;
    //Add传给了pf，pf 等同于 Add ,那么我们也可以这样写。 
    //int sum = pf(2.3)
    return 0;
}

函数指针数组

存放函数指针的数组。

我们将函数指针数组命名为arr，arr数组的每个元素的类型是：int (*)(int,int)

函数指针数组的类型表示：

  int （*[4])(int,int)

怎么理解这函数指针数组的形式？

  arr与[4]结合，说明arr是数组，这个数字的每个元素是int(*)(int,int),而这正好是函数指针类型。

int （*arr[4])(int,int) = {Add,Sub,Div,Mul};

7f747b1e3e234bfea78e57b5b34e0ecf.png

回调函数 

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

这里的函数指针是pf，pf指向的函数是Add，通过pf调用Add，我们称Add为回调函数。

int Add(int x,int y)
{
    return x + y;
}

int main()
{
    int (*pf)(int ,int) = Add;
    int sum = pf(2.3);
    return 0;
}

笔试题

一维数组

题目：

以下打印的结果分别是什么？

 int a[] = {1,2,3,4};
1|printf("%d\n",sizeof(a));
2|printf("%d\n",sizeof(a+0));
3|printf("%d\n",sizeof(*a));
4|printf("%d\n",sizeof(a+1));
5|printf("%d\n",sizeof(a[1]));
6|printf("%d\n",sizeof(&a));
7|printf("%d\n",sizeof(*&a));
8|printf("%d\n",sizeof(&a+1));
9|printf("%d\n",sizeof(&a[0]));
10|printf("%d\n",sizeof(&a[0]+1));

数组名的理解，指针的运算和指针类型的意义

解析：

1.printf (" %d\n ", sizeof ( a ) );  16

  sizeof(数组名），数组名表示整个数组，计算的是整个数组的大小，单位是字节

2.printf (" %d\n ", sizeof( a+0 ) );  4 / 8

  a不是单独放在sizeof内部，也没有取地址，所以a就是首元素的地址，a+0还是首元素的地址。是地址，大小就是4 / 8个字节。地址的大小和环境有关，32位的系统环境就是4个字节，64位系统环境就是8个字节。

3.printf (" %d\n ", sizeof( *a ) );  4

   *a中的a是数组数组首元素的地址，*a就是对首元素的地址解引用，找到的就是首元素，

   首元素是整形，所占内存大小是4个字节

4.printf (" %d\n ", sizeof( a+1 ) );  4 / 8

  a不是单独放在sizeof的内部，a表示的是首元素的地址，a+1就是数组第二个元素的地址

  地址的大小是4个字节或者8个字节。

5.printf (" %d\n ", sizeof( a[1] ) );  4

 a[1]表示的是数组的第二个元素，作为整形元素的大小为4个字节

6.printf (" %d\n ", sizeof( &a ) );   4 / 8

&a,&数组名，这里的a表示的是整个数组的地址，一共4个元素，地址的大小是4个字节。虽然说是整个数组的地址，但是还是通过首元素的地址来表达。

注意：首元素的地址和数组的地址虽然表现是同一个地址，但是它们的运算的结果是不一样的。

比如：&a+1和a+1,一个表示的是跳过了一个（4个整形元素的）数组的地址，一个表示的是数组第二个元素的地址

28e8fa60560a4df6bef26378a712c082.png

44445ab63d2e4185a4fa0ec1a52a5f48.png

7.printf (" %d\n ", sizeof( *&a ) );  16 

&a取的是整个数组的地址，对&a进行解引用，得到的是整个数组，一共4个元素，一个整形元素的大小为4个字节，一共是16个字节

8.printf (" %d\n ", sizeof( &a+1 ) );  4 / 8

&数组名，取的是整个数组的地址，&a再加上1，就是跳过一个数组的位置，然后再取了一个相同大小数组的地址。&a+1还是地址，地址的大小就是4 / 8个字节。

f4300d1fb13a4d5ca2ce296cc73a35a3.png

9.printf (" %d\n ", sizeof( &a[0] ) );  4 / 8

&a[0]取的是数组第一个元素的地址，大小是4个字节或者8个字节。

10.printf (" %d\n ", sizeof( &a[0]+1 ) );  4 / 8

&a[0],取的是数组第一个元素的地址，&a[0]+1就是数组第二个元素的地址。大小是4个字节或者8个字节。

8576a460e35346ad96f67c087fb32bc7.png

总结：

1.数组名大多数表示首元素的地址，有两个例外：1.sizeof（数组名）2.&数组名。数组名表示的是整个数组 。

2.不同类型地址跳过的字节不一样，&a+1，&a表示的是整个数组，+1就会跳过一个数组的大小。&a[0]+1,&a[0]是数组第一个元素的地址，所以+1跳过的是一个元素的大小。

3.地址意义可能不同，但是地址的大小都是4 / 8个字节。

字符数组

题目1：

以下打印的结果是什么？

char arr[] = {'a','b','c','d','e','f'};
1|printf("%d\n",sizeof(arr));
2|printf("%d\n",sizeof(arr+0));
3|printf("%d\n",sizeof(*arr));
4|printf("%d\n",sizeof(arr[1]));
5|printf("%d\n",sizeof(&arr));
6|printf("%d\n",sizeof(&arr+1));
7|printf("%d\n",sizeof(&arr[0]+1));

解析：

1| printf (" %d\n " , sizeof ( arr ) )  6

sizeof(数组名)，取的是整个数组的大小，字符数组arr一共6个元素，所以大小为6个字节。

2|printf (" %d\n ", sizeof( arr+0 ) )  4 / 8 

arr并没有单独放在sizeof内部，所以arr表示首元素的地址，arr+0也表示首元素的地址。是地址，那么大小就为4个字节或者8个字节。

3|printf (" %d\n ",sizeof ( *arr ) )  1

arr是首元素的地址，就是 ‘a’ 的地址，然后解引用，就是‘a’，char类型，大小是1个字节。

*arr 等价于arr [ 0 ]

*(arr+0) 等价于 arr [ 0 ]

4|printf (" %d\n ", sizeof( arr[1] ) )   1

 arr[1]是数组第二个元素，‘b'，大小是1个字节。

5|printf (" %d\n ", sizeof( &arr ) )   4 / 8

&arr取的是数组的地址，是地址就是4 / 8 个字节。

6|printf (" %d\n ", sizeof( &arr+1 ) )  4 / 8

&arr取的是arr数组的地址，&arr+1跳过一个（6个字符元素的）数组，下图是&arr+1的地址位置，是地址，大小就是4个字节或者8个字节。

5777d152fa5247048a45c4926bbd3b8a.png

7|printf (" %d\n ", sizeof( &arr[0]+1 ) )   4 / 8

&arr[0]取的是数组第一个元素的地址，&arr[0]+1就是第二个元素的地址，是地址，就是4个字节或者8个字节。

题目2：

以下的打印结果分别是什么？

char arr[] = {'a','b','c','d','e','f'};
1|printf("%d\n",strlen(arr));
2|printf("%d\n",strlen(arr+0));
3|printf("%d\n",strlen(*arr));
4|printf("%d\n",strlen(arr[1]));
5|printf("%d\n",strlen(&arr));
6|printf("%d\n",strlen(&arr+1));
7|printf("%d\n",strlen(&arr[0]+1));

解析：

strlen

用来求字符串长度的库函数，参数是地址，从参数传来的地址开始，直到有' \0 '停止。

4e914baee0124f0c9d149f48f6dc6570.png

1|printf (" %d\n ", strlen ( arr ) )  随机值

arr为数组首元素的地址，字符数组没有' \0 ',strlen会运行完数组，还会继续运行，直到遇到' \0',但是数组外的元素不由数组控制，也就是说，' \0 '什么时候出现是不可知的，所以会打印随机值。

下图遇到' \0 '前一共19个元素，所以打印结果为19。

' \0 '的ASCII的数字就是0.

a930f1a963e84e2daec2a9d866209b2a.png

2|printf (" %d\n ", strlen ( arr+0 ) )  随机值

arr+0也是首元素的地址，其实和前面问题的随机值是一样的。这里也将会在第20个元素遇到 ‘\0’，所以这里的随机值与 1| 一样。 

3|printf (" %d\n ", strlen ( *arr ) )  访问冲突

strlen的参数是地址，而*arr传过去的是 ’a‘ ，’a'的ASCII值为97，，不是一个地址，就会发生访问冲突，也就是野指针问题。

0df30a8d1e5342439772e9eb7465fb73.png

4|printf (" %d\n ", strlen ( arr[1] ) )  访问冲突

和前面一个问题产生的结果一样，既然strlen函数的参数是地址，将值传过去就会产生野指针的问题。

1b2750333260499497d5800b89bfde10.png

5|printf (" %d\n ", strlen ( &arr ) )  随机值

&arr传过去的是整个数组的地址，strlen用const char* str来接收，那么strlen又是怎么运行的呢？这里的地址和1|、2|类型不同，但是地址的位置是相同的，strlen也应该是从首元素开始一个一个筛查，直到遇到 ‘\0’ ，求字符串才算结束。所以这里和1|、2|的结果应该是一样的。

6|printf (" %d\n ", strlen ( &arr+1 ) )  随机值 - 6

&arr+1，&arr取的是整个数组的地址，&arr+1会跳过一个（6个char类型元素的）数组，下图标记&arr+1的地址位置，strlen函数也就是从这里开始运行，直到遇到 ‘\0’ ,那么这里的结果就会比1|、2|、5|的结果少6个元素。结果：随机值 - 6

5777d152fa5247048a45c4926bbd3b8a.png

 c56cefbf1a0d41a4b20ac22e6866bfaa.png

7|printf (" %d\n ", strlen ( &arr[0]+1 ) )  随机值 - 1

&arr[0]取的是数组第一个元素的地址，&arr[0]+1就是数组第二个元素的地址，从第二个元素开始，strlen遇到 '\0' 停止，就会比1|、2|、5|的结果少1个元素。结果：随机值 - 1.

1420b7347ef945ceac46fbf170baa20d.png

 总结：

1.strlen（const char* str）传递的参数是地址，如果传递数值的话，就会产生访问冲突的问题。

2.strlen不管地址的类型，只管地址的位置，从地址的位置开始，逐个去数字符，直到遇到 \0 ,strlen就停止运行，求出字符串的长度。

题目3：

以下打印的结果是什么？

char arr[] = "abcdef";
1|printf("%d\n",sizeof(arr));
2|printf("%d\n",sizeof(arr+0));
3|printf("%d\n",sizeof(*arr));
4|printf("%d\n",sizeof(arr[1]));
5|printf("%d\n",sizeof(&arr));
6|printf("%d\n",sizeof(&arr+1));
7|printf("%d\n",sizeof(&arr[0]+1));

解析：

char arr[] = "abcdef",这个数组的元素为[ a b c d e f \0 ],一共7个元素，字符串默认以 \0 结尾。

1|printf (" %d\n ", sizeof ( arr ) )   7

sizeof(数组名)，这里的数组名表示的是整个数组，因为字符串默认为 ‘\0’ 结尾，所以这个数组有7个元素，结果为7个字节。

2|printf (" %d\n ", sizeof ( arr+0 ) )  4 / 8

arr表示的是首元素的地址，arr+0表示首元素的地址，是地址，地址的大小为4个字节或者8个字节。

3|printf (" %d\n ", sizeof ( *arr ) )   1

arr表示首元素的地址，*arr取的是‘a’,大小为1个字节。

4|printf (" %d\n ", sizeof ( arr[1] ) )  1

arr[1]为数组的第二个元素，‘b’，大小为1个字节。

5|printf (" %d\n ", sizeof ( &arr ) )  4 / 8

&arr取的是整个数组的地址，地址的大小为4个字节或者8个字节。

6|printf (" %d\n ", sizeof ( &arr+1 ) )  4 / 8

&arr取的是整个数组的地址，&arr+1跳过1个（7个元素）的数组，跳过一个数组，但是地址的类型是不变的，是还是一个数组的地址，不过既然是地址，地址的大小为4个字节或者8个字节。

7|printf (" %d\n ", sizeof ( &arr[0]+1 ) )  4 / 8

&arr[0]取的是数组第一个元素的地址，&arr+1就是数组第二个元素的地址，地址的大小为4个字节或者8个字节。

总结：

1.不管地址的类型是什么，只要是地址，地址的大小就是4个字节或者8个字节。

2.字符串相当于普通的字符数组，但是字符串通常默认 \0 为结尾。

3.sizeof 只关注占用内存空间的大小，不在乎内存中放的是什么。

题目4：

以下打印的结果是什么？

char arr[] = "abcdef";
1|printf("%d\n",strlen(arr));
2|printf("%d\n",strlen(arr+0));
3|printf("%d\n",strlen(*arr));
4|printf("%d\n",strlen(arr[1]));
5|printf("%d\n",strlen(&arr));
6|printf("%d\n",strlen(&arr+1));
7|printf("%d\n",strlen(&arr[0]+1));

解析：

char arr[] = "abcdef",这个数组的元素为[ a b c d e f \0 ],一共7个元素，字符串默认以 \0 结尾。

strlen是求字符串长度的，关注的是字符串中的 \0 ，计算的是 \0 之前出现的字符的个数。

1|printf (" %d\n" , strlen ( arr ) )   6

arr是首元素的地址，遇到 \0 停止。结果：6

2|printf (" %d\n ", strlen ( arr+0 ) )  6

6cef88ae4add4d9bb256ec7e860278be.png

3|printf (" %d\n ", strlen ( *arr ) )  访问冲突

传递的不是地址。

4|printf (" %d\n ", strlen ( arr[1] ) )  访问冲突

传递的不是地址。

5|printf (" %d\n ", strlen ( &arr ) )  6

取的是整个数组的地址，但是地址位置是首元素的地址。

a6189cc5e1184190a12252cc0e059635.png

6|printf (" %d\n ", strlen ( &arr+1 ) )  随机值

跳过了一个数组，\0也包括在这个数组里面，strlen就会往下去寻找 \0 ,结果会是随机值。

ce5c6a377b0b410d9212e4e7725448c7.png

7|printf (" %d\n ", strlen ( &arr[0]+1 ) )  5

从第二个元素开始，后面遇到 \0,一共是5个元素。 

26bbfc0f3d2e4029af0c6c7168fa0383.png

总结：

1. strlen是求字符串长度的，关注的是字符串中的 \0 ，计算的是 \0 之前出现的字符的个数。

2.sizeof 只关注占用内存空间的大小，不在乎内存中放的是什么。

题目5：

char* p = "abcdef";
1|printf("%d\n",sizeof(p));
2|printf("%d\n",sizeof(p+1));
3|printf("%d\n",sizeof(*p));
4|printf("%d\n",sizeof(p[0]));
5|printf("%d\n",sizeof(&p));
6|printf("%d\n",sizeof(&p+1));
7|printf("%d\n",sizeof(&p[0]+1));

答案：

这里的“abcdef”并不是数组，而是常量字符串，常量字符串在内存中有独立的地址。p接收的是首元素’a‘的地址。 

1|printf (" %d\n ", sizeof ( p ) )  4 / 8

p是 指针变量，存放的是’a‘的地址。地址的大小为4个字节或者8个字节。

2|printf (" %d\n ", sizeof ( p+1 ) )  4 / 8

p+1是地址。

3|printf (" %d\n ", sizeof ( *p ) )  1

*p是 ’a‘，大小是1个字节 

4|printf (" %d\n ", sizeof ( p[0] ) )  1

p[0]是’a‘，大小是1个字节。

5|printf (" %d\n ", sizeof ( &p ) )  随机值

&p是地址，p是指针变量，p存放的是常量字符串首元素’a‘的地址，但是p的地址与常量字符串没有关系，p的地址属于二级指针，一级指针的地址。所以是随机值。

218abad8da964427a1eb6ccacf597e57.png

6|printf (" %d\n ", sizeof ( &p+1 ) )  4 / 8

&p+1是地址。所以大小为4个字节或者8个字节。

41a6ad4d76e74a068636f77aebff53d2.png

7|printf (" %d\n ", sizeof ( &p[0]+1 ) )  4 / 8

&p[0]+1是地址。&p[0]就是‘a’的地址，+1就是‘b’的地址。

题目6：

char* p = "abcdef";
1|printf("%d\n",strlen(p));
2|printf("%d\n",strlen(p+1));
3|printf("%d\n",strlen(*p));
4|printf("%d\n",strlen(p[0]));
5|printf("%d\n",strlen(&p));
6|printf("%d\n",strlen(&p+1));
7|printf("%d\n",strlen(&p[0]+1));

答案：

1|printf (" %d\n ", strlen( p ) )  6

p是首元素‘a’的地址，往后6个元素，到 \0 停止。

53218d81d5c947378c779058678b5e6f.png

2|printf (" %d\n ", strlen( p+1 ) )  5

p+1是第二个元素的地址，往后5个元素，到 \0 停止。

19f9e1612a884cfc85179ef79f1c61ce.png

3|printf (" %d\n ", strlen ( *p ) )  访问冲突

strlen的参数为地址。

4|printf (" %d\n ", strlen ( p[0] ) )  访问冲突

strlen的参数为地址。

5|printf (" %d\n ", strlen ( &p ) )  随机值

p是一级指针，&p就是二级指针。p的地址和常量字符串“abcdef”没有关系。

3ab1a2eb9f5d484daff9fbd688f8d289.png

6|printf (" %d\n ", strlen( &p+1 ) )  随机值 - 1

&p取的是p的地址，&p指向p的下一位。

a00d0a1fcb7240288ce80d832e386aea.png

7|printf (" %d\n ", strlen ( &p[0]+1 ) )  5

p[0]就是’a‘,&p[0]取出了’a‘的地址，&p[0]+1就是’b‘的地址。

strlen从’b‘开始往后数，一直数到 \0为止，一共是5个元素。

28952f72d15d4243bff649cee8d86318.png

猪巴戒
关注
  • 126
    点赞
  • 踩
  • 132
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 97
    评论
专栏目录
C语言推荐书籍从入门到进阶带你走上大牛之路（珍藏版）
CodeAllen嵌入式
10-20 5万+
微信交流群，添加微信「coderAllen」（回复“进群”） QQ技术交流①群（736386324） 书籍介绍 一.C语言入门，初学，编程基础系列 1.《C语言程序设计：现代方法》（第2版） 推荐理由：时至今日， C语言仍然是计算机领域的通用语言之一，但今天的 C语言已经和最初的时候大不相同了。本书最主要的一个目的就是通过一种“现代方法”来介绍 C语言，书中强调标准 C，强调软件工程，不再强调...
(C语言进阶)笔试题详解
2301_79580018的博客
10-14 297
/01 00 00 00 | 02 00 00 00 | 03 00 00 00 | 04 00 00 00——在内存中存储（小端存储）//00 00 00 01 | 00 00 00 02 | 00 00 00 03 | 00 00 00 04——数组中元素地址。//cpp[-2]—>*(cpp-2)—>元素c+3—>"FIRST"的地址。//cpp[-1]—>*(cpp-1)—>元素c+2—>"POINT"的地址。//cpp[-1][-1]—>*(cpp[-1]-1)—>"NEW"的地址。
笔试题详解（C语言进阶）
Pxiaoyao的博客
02-21 603
通过一个实际案例来讲解C语言中不同类型的字节大小。
C语言进阶之笔试题详解（2）
2302_79491024的博客
11-30 1955
这里的内容包括二维数组笔试题和指针笔试题，供给读者对这部分知识进行加深和巩固。✨猪巴戒个人主页✨所属专栏《C语言进阶》🎈跟着猪巴戒，一起学习C语言🎈数组名的意义：1.sizeof（数组名），这里的数组名表示整个数组，计算的是整个数组的大小。2.&数组名，这里的数组名表示整个数组，去除掉是整个数组的地址。3.除此之外所以的数组名都表示首元素的地址。4.二维数组可以看作有多个一维数组组成，一维数组可以看作二维数组的每个元素，行数代表制二维数组的意思个数，列数代表一维数组的元素个数。
【C语言进阶】经典笔试题详解之指针篇
森林里的白杨
05-12 596
一、二维数组 代码块①： 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("⑦ %
【C语言进阶】经典笔试题数组篇之一维数组详解
森林里的白杨
04-26 3157
一、知识回顾 sizeof(数组名) -数组名表示整个数组的大小，计算整个数组的大小； &数组名：表示整个数组； 除此之外，所有的数组名都是数组首元素的地址； sizeof()，求字符串长度时，字符串后自带有\0，也会被记录在内； strlen(),求字符串长度，遇到\0后结束； 二、题目 2.0 一维数组 代码块①： int main() { int a[] = { 1,2,3,4 }; printf("① %d\n", sizeof(a)); printf("② %d\
【C语言进阶】C指针详解之练习（附解析）
HyDraZya的博客
08-27 1615
首先我们再来重新认识一下数组名的概念 数组名是首元素的地址 1.sizeof(数组名)-数组名表示整个数组 2.&数组名-数组名表示整个数组 注意：上面这两种情况都需要 sizeof() / &后面直接+数组名，如果不是直接 + 数组名，则不是表示整数数组。除了上述两种情况外，其余所有情况数组名均表示的是首元素地址。 那么接下去我们就来看题目叭！ 一、请写出下面程序执行的结果 //一维数组 int a[] = {1,2,3,4}; printf("%d\n",s...
【C语言进阶】指针面试题详解
taro_yuan的博客
04-18 405
C语言进阶指针面试题详解
【C语言进阶学习笔记】二、指针的进阶（3）（练习篇）
大家好我叫张同学
06-08 1772
本篇文章的内容为指针进阶的相关练习题目，主要是进行指针的练习和巩固，继续上一篇指针相关的内容。【C语言进阶学习笔记】二、指针的进阶（2）（重点必看+代码演示+练习） 文章目录一、指针和数组经典笔试题解析：1、请写出下面程序执行的结果2、请写出下面程序执行的结果3、请写出下面程序执行的结果4、请写出下面程序执行的结果5、请写出下面程序执行的结果6、请写出下面程序执行的结果7、请写出下面程序执行的结果8、请写出下面程序执行的结果二、指针笔试题：笔试题1：笔试题2：笔试题3：笔试题4：笔试题5：笔试题6：笔试题
c语言指针的进阶
weixin_47270825的博客
10-16 609
函数指针 获得函数地址的方式可以是函数名和&函数 两个值的结果相同。 保存函数地址的变量称为函数指针变量
Python 数据结构：字典与集合的详细对比
08-31 511
在 Python 编程语言中，字典（dictionary）和集合（set）是两种非常核心且功能强大的数据结构。它们在处理数据时扮演着不同的角色，了解它们的区别对于编写高效、清晰的代码至关重要。本文将详细介绍字典和集合的特点、用法以及何时使用它们。
数据结构
2301_80184169的博客
08-28 563
4.执行代码,复现段错误,产生包含出错信息的core文件(检查core文件是否生成)3.ulimit -c unlimited 不限制core文件的生成的大小。使用这种方法能够很好的解决段错误，在纠正和优化代码时效率显著提升。1.首先按照如下的方法配置Ubuntu，允许生成core文件。5.gdb a.out core 查看段错误产生的位置。2.重新编译代码并加入-g选项(允许进行GDB调试)
数据结构（邓俊辉）学习笔记】串 10——BM_BC算法：坏字符
weixin_44399845的博客
08-28 863
BM_BC算法：坏字符
【数据结构】队列(Queue)
xiaochuan_bsj的博客
08-28 865
数组，双链表实现队列，附完整代码
【手撕数据结构】二叉树的性质
最新发布
apple_61439616的博客
08-31 248
目录叶子节点和边的性质概念小试牛刀 叶子节点和边的性质 概念 可以看到度为0的节点如F没有边，度为1的节点如C有一条边，而度为2的节点如B有两条边。 那么设度为2的节点为a个，度为1的节点为b个。二叉树边 = 2a+b 另⼀⽅⾯，由于共有 a+b+c 个节点，所以边数等于 a+b+c-1 这里-1是因为： 综合上面两个公式，我们2a+b = a + b + c - 1; 推出c = a+1(c为度为0节点，a为度为2节点) 所以叶子结点n0 = n2 + 1; 小试牛刀 这道题已经告诉了我们度
Java-数据结构-包装类和认识泛型 !!!∑(ﾟДﾟノ)ノ
2303_80388948的博客
08-27 1199
对于泛型就是：使用与许多许多类型。从代码上来说呢，就是对类型实现了参数化。对于引出泛型，我们来实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。在这里呢，我们用 Object类 来进行创建数组，Object是所有类的父类，但是呢，我们在这里呢就有一些问题，我们来看看：1、在这里呢，我们这个数组当中可以存放任何类型2、我们每次进行的到值时候呢，都要进行强转。
数据结构—链表
2301_79909332的博客
08-27 753
数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。数据量增长与程序所占用空间的比例关系称为空间复杂度。顺序表、链式表、顺序栈、链式栈、顺序队列、链式队列 、树 二叉树。使用该函数遍历顺序表内元素，符合条件的可对其进行计数和打印。使用该函数遍历顺序表内元素，符合条件的对其进行修改。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。1.空间可以不连续，访问元素不方便。3.程序 = 数据结构 + 算法。4.链表的插入和删除效率很高。
集合及数据结构第十三节（下）———— 枚举与Lambda表达式
2301_79418684的博客
08-27 1193
枚举与枚举的使用 1. 什么是C语言 2. 数据类型 3. 变量、常量 4. 字符串+转义字符+注释 5. 选择语句 6. 循环语句 7. 函数 8. 数组 9. 操作符 10. 常见关键字 11. define 定义常量和宏 12. 指针 13. 结构体
Java算法之插入排序（Insertion Sort）
weixin_38959316的博客
08-29 302
插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。这个过程像打牌时整理手中的牌一样，逐步将数据排列成有序。插入排序虽然在实际应用中的效率不如一些更高级的排序算法，但它的原理简单，易于实现，且对于部分有序的数据集表现良好。
C语言进阶：存储器与指针详解
本资源深入探讨了C语言进阶中的重要主题——存储器与指针。首先，存储器是计算机程序中的关键组成部分，它用于临时或永久保存数据。理解内存管理对程序性能和效率至关重要。在C语言中，内存陷阱可能隐藏着潜在的问题...
评论 97
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猪巴戒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值