AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

C语言指针就应该这么学 - 指针的进阶篇 下

2022-05-16 92
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C语言指针就应该这么学 - 指针的进阶篇

十、指针和数组笔试题解析

1、实例1

💨 在此之前我们先回顾一下数组名：

▶ 一、sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小

▶ 二、&数组名，这里的数组名表示整个数组，取出的是整个数组的地址

▶ 三、除此之外所有的数组名都表示数组首元素的地址

注：在下面实例中，我会在每条语句的后面写上正确的输出结果，并用一、二、三(代表上面的场景)来配合解释 -> 【正确答案：一/二/三】-> 更详细的解释

1.1、一维数组

#include<stdio.h>
int main()
{
  int a[] = {1,2,3,4};
  printf("%d\n",sizeof(a));//【16：一】-> 4*4=16
  printf("%d\n",sizeof(a+0));//【4/8：三】-> sizeof(首元素地址)
  printf("%d\n",sizeof(*a));//【4：三】-> sizeof(1)
  printf("%d\n",sizeof(a+1));//【4/8：三】-> sizeof(2)  
  printf("%d\n",sizeof(a[1]));//【4：三】-> sizeof(2)
  printf("%d\n",sizeof(&a));//【4/8：二】
  printf("%d\n",sizeof(*&a));//【16：二】-> &和*可以抵消
  printf("%d\n",sizeof(&a+1));//【4/8：二】-> sizeof(跳过a数组后面的数组的地址)
  printf("%d\n",sizeof(&a[0]));//【4/8：三】-> 因为[]的优先级 > &，因此sizof(&1)
  printf("%d\n",sizeof(&a[0]+1));//【4/8：三】-> sizeof(&2)
  return 0;
}
  • 小结

这里主要注意的是：

这里&a是取出整个数组的地址，+1就跳过了这个数组

1.2、字符数组

#includ<stdio.h>
int main()
{
  char arr[] = {'a','b','c','d','e','f'};
  printf("%d\n", sizeof(arr));//【6：一】-> sizeof(数组总大小)，
  printf("%d\n", sizeof(arr+0));//【4/8：三】-> sizeof(&a)
  printf("%d\n", sizeof(*arr));//【1：三】-> sizeof(a)
  printf("%d\n", sizeof(arr[1]));//【1：三】-> sizeof(b)
  printf("%d\n", sizeof(&arr));//【4/8：二】-> sizeof(数组的地址)
  printf("%d\n", sizeof(&arr+1));//【4/8：二】-> sizeof(跳过arr数组后面的数组的地址)
  printf("%d\n", sizeof(&arr[0]+1));//【4/8：三】-> sizeof(&b)
  //---------------------------------分割线-----------------------------------
  printf("%d\n", strlen(arr));//【19：随机值】-> strlen(&a)，strlen在求字符串长度时是以'\0'为标志的，且不包含'\0'
  printf("%d\n", strlen(arr+0));//【19：随机值】-> strlen(&a)
  printf("%d\n", strlen(*arr));//【err：三】-> strlen(a)，strlen只能传地址
  printf("%d\n", strlen(arr[1]));//【err：同上】-> strlen(b)
  printf("%d\n", strlen(&arr));//【19：随机值】-> 这里虽然计算的是地址，站在strlen的角度strlen会把数组指针的类型转换为一级指针，然后会从a的地址开始往下找
  printf("%d\n", strlen(&arr+1));//【13：随机值}-> 这里会从arr数组最后一个元素的后面往下找
  printf("%d\n", strlen(&arr[0]+1));//【18：随机值】-> 这里是从arr数组第2个元素开始往下数
  //---------------------------------分割线-----------------------------------
  char arr2[] = "abcdef";
  printf("%d\n", sizeof(arr));//【7：一】-> sizeof(数组大小)
  printf("%d\n", sizeof(arr+0));//【4/8：三】-> sizeof(&a)
  printf("%d\n", sizeof(*arr));//【1：三】-> sizeof(a)
  printf("%d\n", sizeof(arr[1]));//【1：三】-> sizeof(b)
  printf("%d\n", sizeof(&arr));//【4/8：二】-> sizeof(&数组的地址)
  printf("%d\n", sizeof(&arr+1));//【4/8：二】-> sizeof(跳过数组后的地址)
  printf("%d\n", sizeof(&arr[0]+1));//【4/8：三】sizeof(&b)
  //---------------------------------分割线-----------------------------------
  printf("%d\n" , str1en(arr));//【6：】-> strlen在计算字符串长度时，不会包含'\0'
  printf("%d\n", strlen(arr+O));//【6：】-> strlen(&a)
  printf("%d\n", strlen(*arr));//【err：】-> strlen(a)
  printlf ("%d\n", strlen(arr[1]));//【err：】-> strlen(b)
  printf("%d\n",strlen(&arr));//【6：】-> strlen(&a)
  printf("%d\n", strlen(&arr+1));//【12：随机值】-> strlen(跳过数组后的地址)
  printf("%d\n",strlen(&arr[O]+1));//【5：】-> strlen(&b)
  return 0;
}
  • 小结

一、strlen在计算字符串长度时是以’\0’为标志的，且不会计算’\0’

二、在使用strlen去计算字符串数组时

三、之前我们在模拟strlen函数的时候 -> int my_strlen(const char* str)它的参数是一个指针，应该接收地址，而这里传的是一个字符

所以err：

四、当strlen的参数是一个数组的地址时

这里计算的是整个数组地址，在传参的过程中把数组的地址传给一级指针时，这时数组的类型就会变成char*，因为这里是strlen说了算，站在strlen的角度往后数也是一个随机值,

五、当我们比较这三条语句时：

1.3、指针指向的字符串

#include<stdio.h>
int main()
{
  char* p = "abcdef";
  printf("%d\n", sizeof(p));//【4/8：】-> sizeof(&a) 
  printf("%d\n", sizeof(p+1));//【4/8：】-> sizeof(&b)
  printf("%d\n", sizeof(*p));//【1：】-> sizeof(a)
  printf("%d\n", sizeof(p[0]));//【1：】->sizeof(a)
  printf("%d\n", sizeof(&p));//【4/8：】-> sizeof(p指针的地址)
  printf("%d\n", sizeof(&p+1));//【4/8：】-> sizeof(跳过p指针的地址)
  printf("%d\n", sizeof(&p[0]+1));//【4/8：】-> sizeof(&b)
  //---------------------------------分割线-----------------------------------
  printf("%d\n",strlen(p));//【6：】-> strlen(&a)  
  printf("%d\n",strlen(p+1));//【5：】-> strlen(&b)
  printf("%d\n",strlen(*p));//【err：】-> strlen(a)
  printf("%d\n", strlen(p[0]));//【err：】-> strlen(a) 
  printf("%d\n",strlen(&p));//【3：随机值】-> strlen(p指针的地址)
  printf("%d\n", strlen(&p+1));//【11：随机值】-> strlen(跳过p指针的地址)
  printf("%d\n", strlen(&p[0]+1));//【5：】-> strlen(&b)
  return 0;
}
  • 小结：

一、这里关于指针和数组名有一些关联：

int arr[10] = {1,2,3,4,5,6,7,8,9,10};

int* p = arr;

可推出：arr[2] < == > *(arr + 2) < == > *(p + 2) < == > *(2 + p) < == > *(2 + arr) < == > 2[arr]

二、当我们取指针的地址时：

1.4、二维数组

#include<stdio.h>
int main()
{
  int a[3][4] = {0};
  printf("%d\n" , sizeof(a));//【48：一】-> 3*4*4=48
  printf("%d\n", sizeof(a[0][O]));//【4：三】-> sizeof(第一行数组名[0])
  printf("%d\n" , sizeof(a[0]));//【16：一】-> sizeof(第一行数组名)
  printf("%d\n" , sizeof(a[0]+1));//【4/8：三】-> 因为数组名没有单独放到sizeof里，所以sizeof(第1行第2个元素的地址)
  printf("%d\n" ,sizeof(*(a[0]+1)));//【4：三】-> sizeof(*(第1行第2个元素的地址))
  printf("%d\n" , sizeof(a+1));//【4/8：三】-> 这里a表示首元素地址(a[0])，所以a+1就是第二行数组的地址
  printf("%d\n" ,sizeof(*(a+1)));//【16：三】-> 这里计算的是第2行数组的大小
  printf("%d\n" , sizeof(&a[0]+1));//【4/8：二】-> &a[0]取出第1行数组的地址，因此它计算的是第2行数组的地址
  printf("%d\n" ,sizeof(*(&a[0]+1)));//【16：二】-> 这里计算的是第2行数组的大小
  printf ("%d\n" ,sizeof(*a));//【16：三】-> 这里表数组首元素地址a[0]，因此计算的是第1行数组的大小
  printf("%d\n" ,sizeof(a[3]));//【16：一】-> 这里并没有真正的去访问a[3]，而是根据a[3]的类型int[4]去计算大小  
  return 0;
}
  • 小结

一、二维数组的数组名

二、sizeof去计算越界的数组

这里为什么不是err？

因为sizeof内部的表达式是不计算的，所以我们不论越界多大都不会err

我们在写任何一个表达式(3+5)时它都有两个属性：

1、值属性 - 8

2、类型属性 - int

所以对于sizeof我们根本不需要知道表达式运算的值是多少，只要能够算出来结果是int类型就行了sizeof(3+5) -> 4。所以a[3]的类型是int[4]


补充(看一道例子)：

int main()

{

  short s = 5;

  int a = 4;

  printf("%d\n", sizeof(s = a + 6);// 2 - 这里不管是多大s说了算

  printf("%s\n", s);// 5 - 证明了sizeof不会去计算()里的表达式

  return 0;

}

2、实例2

#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));//2,5
  return 0;
}
  • 分析：

---------------------------* (ptr - 1)---------------------------

---------------------------* (a + 1)---------------------------

3、实例3

#include<stdio.h>
//由于还没有学习结构体，这里告知结构体的大小是20个字节
struct Test
{
  int Num;
  char* pcName;
  short sDate;
  char cha[2];
  short sBa[4];
}*p;
//假设p的值为0x100000，如下表达式的值分别是多少？
int main()
{
  //0x1就是十六进制的1，它同十进制的1
  printf("%p\n", p + 0x1);//0x100014
  printf("%p\n", (unsigned long)p + 0x1);//0x100001
  printf("%p\n", (unsigned int*)p + 0x1);//0x100004
  return 0;
}
  • 分析

经分析，这里考察指针类型决定了指针的运算

---------------------------p + 0x1---------------------------

p的类型是struct Test，且占20个字节。而p+1跳过这个结构体(20个字节)

0x100000 + 1 == 0x100014(需要注意的是十进制20要先转换为十六进制)

---------------------------(unsigned long)p + 0x1---------------------------

这里主要注意的是：

非指针类型的变量+1，那它+1加的就是1

(unsigned long)p + 0x1);

0x100000 + 1 == 0x100001


只有是指针类型的变量+1才跳过的是一个类型

(unsigned long*)p + 0x1);

0x100000 + 1 ==0x100004

---------------------------(unsigned int*)p + 0x1)---------------------------

这里是将p强转为int无符号int类型的指针，所以它+1会跳过一个整型

0x100000 + 1 ==0x100004

4、实例4

#include<stdio.h>
int main()
{
  int a[4] ={1,2,3,4};
  int* ptr1 = (int*)(&a + 1);//4
  int* ptr2 = (int*)((int)a + 1);//2000000
  printf("%x,%x", ptr1[-1], *ptr2);
  return 0;
}
  • 分析

---------------------------ptr1[-1]-----------------------

---------------------------*ptr2---------------------------

5、实例5

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

6、实例6

#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]);//FFFFFFFC,- 4
  return 0;
}
  • 分析

---------------------------&p[4][2] - &a[4][2]-----------------------

7、实例7

#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)); //10,5
  return 0;
}
  • 分析

---------------------------(ptr1 - 1)-----------------------
1、&aa取二维数组的地址
2、+1跳过二维数组，此时它的类型是int( * )[2][5]
3、再将它强制类型转换为int后赋值于int* ptr1

4、(ptr1-1)就找到了10

---------------------------(ptr2 - 1)-----------------------

1、aa是首元素的地址，二维数组的首元素是第一行

2、aa+1指向第二行的数组

3、*(aa+1)就对第二行数组解引用，就相当于第二行数组的数组名

   *(aa+1) == aa[1]

  可以说 *(二维数组的首地址)就是数组名

4、此时 *(aa+1)它的类型就是 int *，可以直接赋值于 int * ptr2

8、实例8

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

9、实例9

#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);//POINT
  printf("%s\n", *-- * ++cpp + 3);//ER
  printf("%s\n", *cpp[-2] + 3);//ST
  printf("%s\n", cpp[-1][-1] + 1);//EW 
  return 0;
}
  • 分析

先了解一下：

#include<stdio.h>

int main()

{

  int arr[] = { 1,2,3,4,5 };

  int* p;

  p = arr;

  printf("%d\n", *++p);//2

  printf("%d\n", ++p);//3 -> 对于指针类型(地址)的操作，操作的是它的地址，所以本身它会被改变
  int a = 3;
  printf("%d\n", a + 3);//6
  printf("%d\n", a + 3);//6 -> 而对于非指针类型(地址)操作，并不是操作它的地址，所以本身它没有改变
  return 0;
}
-----------------------------图示---------------------------------

-----------------------------**++cpp---------------------------------

-----------------------------– * ++cpp + 3---------------------------------

-----------------------------*cpp[-2] + 3---------------------------------

-----------------------------cpp[-1][-1] + 1---------------------------------

十一、指针的初识篇

C语言精华 - 指针初识篇

文章标签：
C++
C语言
关键词：
C语言指针
C语言进阶篇
C语言指针进阶篇
跳动的bit
目录
相关文章
ephemerals__
|
18天前
|
C语言
【c语言】指针就该这么学(1)
本文详细介绍了C语言中的指针概念及其基本操作。首先通过生活中的例子解释了指针的概念，即内存地址。接着，文章逐步讲解了指针变量的定义、取地址操作符`&`、解引用操作符`*`、指针变量的大小以及不同类型的指针变量的意义。此外，还介绍了`const`修饰符在指针中的应用，指针的运算（包括指针加减整数、指针相减和指针的大小比较），以及野指针的概念和如何规避野指针。最后，通过具体的代码示例帮助读者更好地理解和掌握指针的使用方法。
ephemerals__
44 0
ephemerals__
|
17天前
|
C语言
【c语言】指针就该这么学(3)
本文介绍了C语言中的函数指针、typedef关键字及函数指针数组的概念与应用。首先讲解了函数指针的创建与使用，接着通过typedef简化复杂类型定义，最后探讨了函数指针数组及其在转移表中的应用，通过实例展示了如何利用这些特性实现更简洁高效的代码。
ephemerals__
13 2
c的前世今生
|
18天前
|
C语言
如何避免 C 语言中的野指针问题？
在C语言中，野指针是指向未知内存地址的指针，可能引发程序崩溃或数据损坏。避免野指针的方法包括：初始化指针为NULL、使用完毕后将指针置为NULL、检查指针是否为空以及合理管理动态分配的内存。
c的前世今生
29 2
c的前世今生
|
18天前
|
C语言
C语言：哪些情况下会出现野指针
C语言中，野指针是指指向未知地址的指针，通常由以下情况产生：1) 指针被声明但未初始化；2) 指针指向的内存已被释放或重新分配；3) 指针指向局部变量，而该变量已超出作用域。使用野指针可能导致程序崩溃或不可预测的行为。
c的前世今生
47 1
c的前世今生
|
24天前
|
存储 C语言
C语言32位或64位平台下指针的大小
在32位平台上，C语言中指针的大小通常为4字节；而在64位平台上，指针的大小通常为8字节。这反映了不同平台对内存地址空间的不同处理方式。
c的前世今生
90 7
c的前世今生
|
23天前
|
存储 算法 C语言
C语言：什么是指针数组，它有什么用
指针数组是C语言中一种特殊的数据结构，每个元素都是一个指针。它用于存储多个内存地址，方便对多个变量或数组进行操作，常用于字符串处理、动态内存分配等场景。
c的前世今生
25 3
c的前世今生
|
24天前
|
存储 C语言
C语言指针与指针变量的区别指针
指针是C语言中的重要概念，用于存储内存地址。指针变量是一种特殊的变量，用于存放其他变量的内存地址，通过指针可以间接访问和修改该变量的值。指针与指针变量的主要区别在于：指针是一个泛指的概念，而指针变量是具体的实现形式。
c的前世今生
25 3
星霜旅人
|
24天前
|
C语言
C语言指针（3）
C语言指针（3）
星霜旅人
11 1
星霜旅人
|
24天前
|
C语言
C语言指针（2）
C语言指针（2）
星霜旅人
12 1
ephemerals__
|
17天前
|
编译器 C语言
【c语言】指针就该这么学(2)
本文详细介绍了指针与数组的关系，包括指针访问数组、一维数组传参、二级指针、指针数组和数组指针等内容。通过具体代码示例，解释了数组名作为首元素地址的用法，以及如何使用指针数组模拟二维数组和传递二维数组。文章还强调了数组指针与指针数组的区别，并通过调试窗口展示了不同类型指针的差异。最后，总结了指针在数组操作中的重要性和应用场景。
ephemerals__
15 0

热门文章

最新文章

  • 1
    getkeynametext(键盘消息类型，指针，长度）返回字符串
  • 2
    nim的引用和指针
  • 3
    深入理解C指针之三：指针和函数
  • 4
    C++智能指针(auto_ptr)详解
  • 5
    主讲:A1(老吴) 时间:2004-10-22 15:00 主题:0>一点点编译。1>解决DLL与EXE沟通时String和其它Memory的问题.2>公布hmOlevariants.pas 3>成批的偷别人的音乐文件 4>讨论使用结构好还是类好 5>讨论对象，指针，VMT
  • 6
    C++智能指针的实现
  • 7
    指针难，算法难，难住了谁
  • 8
    C++第17周项目2——用指针玩字符串（1）连接
  • 9
    迷途指针 new delete
  • 10
    深入理解C语言中的指向函数的指针和返回指针的函数
  • 1
    C语言之详细讲解文件操作（抓住文件操作的奥秘）
    46
  • 2
    C语言结构体—自定义类型—struct
    48
  • 3
    C语言—内存函数的实现和模拟实现（内存函数的丝绸之路）
    44
  • 4
    C语言—字符函数与字符串函数（字符问题变简单的关键之技）
    58
  • 5
    C语言之九九乘法表||素数||最小公倍数
    62
  • 6
    C语言详解指针（指针海洋的探索，将传值与传址刻在心里）
    40
  • 7
    C语言——函数递归
    37
  • 8
    C语言扫雷代码（蹦蹦炸弹）（下）
    36
  • 9
    关于我在C语言中玩扫雷（上）
    33
  • 10
    C语言—函数（大化小方式的心脏）
    36

    • 相关课程

    更多
  • 你的第一门C语言课
  • C语言学习教程
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 数据结构和算法

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    无影云桌面