数组降维与多级指针、函数栈帧、地址空间、可变参数原理 ...

目录

• 数组和指针
  
  
  
  • 
    
    
    
    • 多维数组的物理结构
      
    • 证明数组a和&a不同
      
    • 数组与指针的差别之一
      
    • 什么时候数组名表示整个数组?
      
    • 数组训练
      
    • 明确指针与数组的题
      
    • 全部的数组,都可以看成一维数组.全部的数组传参,最终都会降维成一维数组
      
    
    
  
  
• 函数
  
  
  
  • 函数的地址
    
  • 函数的规范
    
  
  
• 内存管理
  
  
  
  • malloc返回给用户的只有申请内存的起始地址,那free是怎样准确开释动态内存申请的空间?
    
  • 内存级cookie
    
  • C语言程序地址空间-内存验证
    
  
  
• 函数栈帧
  
  
  
  • 熟悉相关寄存器
    
  • 熟悉相关汇编下令
    
  • 查看函数调用堆栈
    
  • 函数形成与开释:
    
  
  
• 可变参数列表
  
  
  
  • 可变参数的原理
    
  • C语言提供的可变参数方案
    
    
    
    • stdarg.h
      
      
      
      • va_list
        
      • va_start
        
      • va_arg
        
      • va_end
        
      
      
    • 简单的可变参数程序
      
    • 可变参数的反汇编与内存分析
      
    • 可变参数整型提拔的反汇编分析
      
    • 留意事项
      
    
    
  
  
• 留言
  

数组和指针

多维数组的物理结构

1. int a[3][4] = { 0,1,2,3,4,5,6,7,8,9,10,11 };
2. for (int i = 0; i < 3; i++) {
3.         for (int j = 0; j < 4; j++) {
4.                 printf("a[%d][%d] : %p\n", i, j, &a[i][j]);
5.         }
6. }

复制代码

在C语言中,多维数组都是一维抽象而成的,实际就是一连的多个一维数组.记得这一点,将指针和数组都化作一维来看待,解决这类问题就会简单很多.
证明数组a和&a不同

1. int a[10] = {0};
2. //a是数组首元素地址,&a是数组的地址
4. int (*p)[10] = a;  //警告:间接级别不同
5. int (*p)[10] = &a; //符合

复制代码

数组与指针的差别之一

1. int main()
2. {
3.         int a[4] = { 1,2,3,4 };
4.         int* p = &a + 1;
5.         printf("%d \n", p[-1]); //指针才有的用法: p[-1] == *(p-1)
6.         return 0;
7. }

复制代码

什么时候数组名表示整个数组?

• sizeof(数组名) //sizeof括号内不能再有其他符号
  
• &数组名
  

只有这两种情况才表示整个数组,其他情况数组名都表示数组的首元素地址,a[0]表示数组首元素(内容)
其他情况都会发生降维,降维成指针.
数组训练

1. int a[3][4] = { 0,1,2,3,4,5,6,7,8,9,10,11 };
2. printf("%d\n", sizeof(a)); //二维数组
3. printf("%d\n", sizeof(a[0][0])); //二维数组第一个元素的第一个元素,即第一个一维数组的第一个元素
4. printf("%d\n", sizeof(a[0]));    //二维数组的第一个元素,是第一个一维数组,没有降维,16
5. printf("%d\n", sizeof(a[0] + 1));  
6. //二维数组的第一个元素+1,即降维成第一个一维数组的首元素地址+1.是第一个一维数组的第二个元素的地址.
8. printf("%d\n", sizeof(*(a[0]+1)));  //第一个一维数组的第二个元素
9. printf("%d\n", sizeof(a + 1));  //降维成二维数组第一个元素的地址+1,即二维数组第二个元素的地址
10. printf("%d\n", sizeof(*(a+1)));     //二维数组的第二个元素,即第二个一维数组,没有发生降维,16
11. printf("%d\n", sizeof(&a[0] + 1));    
12. //理解1:二维数组的第一个元素即第一个一维数组取地址,需要一维数组降维成指针,才能进行取地址,数组降维成指针后,就是数组的首元素地址,首元素地址再取地址就成了一维数组. (编译器不支持再升维成数组)
13. //理解2:二维数组的第一个元素取地址,二维数组就已经降维成二维数组的首元素地址,元素取地址,则指针对应的类型是二维数组元素的类型,+1就是加一个元素的大小.即得到二维数组的第二个元素的地址. (这种理解更符合编译器行为)
15. printf("%d\n", sizeof(*(&a[0]+1))); //什么含义？
16. printf("%d\n", sizeof(*a));   //什么含义？
17. printf("%d\n", sizeof(a[3])); //什么含义？

复制代码

明确指针与数组的题

1. int a[5][5] = { 0 };
2. for (int i = 0; i < 25; i++)
3. {
4.         *(&**a + i) = i;
5. }
6. for (int i = 0; i < 25; i++)
7. {
8.         printf("%d ", *(&**a + i));
9. }
10. puts("");
12. int(*p)[4];  //定义一个类型为int[4]的指针变量
13. p = (int(*)[4])a;  //强转只是为了让编译器不警告
14. printf("pa=%p, pb=%p\n", &a[4][2], &p[4][2]);  //问题1
15. printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]); //问题2
17. //先将指针模拟数组多维访问的方式降维成一维的计算方式: p[4][2] = *(*(p + 4) + 2);
18. //然后将数组物理结构图展开
19. //p所指向的类型是int[4],因此步长是4个int
20. //a本身是数组,不需要降维
21. //编译器会查看元素是否是地址,或者说,默认指针计算就是把元素值当作地址.所以不用当心指针解引用后是指针还是数据的影响.

复制代码

数组传参过程,函数形参中括号[]内的常数可以省略.因为数组最终会降维成指针,而指针利用[]就没有数组这样的约束了
全部的数组,都可以看成一维数组.全部的数组传参,最终都会降维成一维数组

• 二维数组降维
  

1. void func(int(*p)[6],int size) //一维数组,数组元素类型为int[6][7][8]
2. { }
4. int main()
5. {
6.         int a[5][6] = { 0 };
7.         func(a,5);
8.         return 0;
9. }

复制代码

• 高维数组降维
  

1. void func(int(*p)[6][7][8],int size)  //一维数组,数组元素类型为int[6][7][8]
2. { }
4. int main()
5. {
6.         int a[5][6][7][8] = { 0 };
7.         func(a,5);
8.         return 0;
9. }

复制代码

验证: 只有第一个中括号能省略,即明确要求降维成一维指针

1. void func(int p[][6][7][8],int size)  
2. { }
4. int main()
5. {
6.         int a[5][6][7][8] = { 0 };
7.         func(a,5);
8.         return 0;
9. }

复制代码

如果省略了指针第一个[]内的数值,则指针的类型就会不明确
//为什么要降维? 不降维就要拷贝整个数组,本钱开销很大,降维成指针后只必要拷贝地址
函数

函数的地址

1. void func()
2. { }
4. int main()
5. {
6.         printf("%p\n", func); //常用
7.         printf("%p\n", &func);
8.         return 0;
9. }

复制代码

C语言中函数名和&函数名完全等价,都代表函数的地址
函数在程序中不可写入,只必要关心它的起始位置在那里
要生存函数的地址,就必要利用函数指针变量
函数指针可以通过圆括号()来调用指向的函数.比方p();
函数的规范

• 在比较长的代码末端处,加上注释
  

//end of if
//end of for

• 长表达式要在低优先级操作符处划分新行,操作符放在新行之首(以便突出操作符).
  
• 原则上只管少利用全局变量,因为全局变量的生命周期太长,容易出错,也会长时间占用空间.其次,在多线程下会有线程安全问题,容易出错
  
• 参数命名:
  新旧值类型的一般遵行从右向左原则,像赋值符号一样,如字符串拷贝函数str_copy(char*dest,const char*src);
  
• 函数功能要单一,不要设计多用途的函数.微软的Win32API就是典型,其函数往往因为参数不一样而功能不一,初学很容易迷惑
  
• 类似的输入应当产生类似的输出.只管避免函数带有"记忆"功能,这样的函数的行为欠好预测,行为取决于某种"记忆".
  "记忆"功能:如static修饰的局部变量,是函数的"记忆"存储器.
  
• 避免函数有太多的参数,详细取决于业务,能简则简.如果参数过多,在利用时容易将参数类型或顺序搞错.
  比方微软的WIN32API,其函数的参数往往有七八个甚至十余个
  
• 类型和数目不确定的参数,要深思熟虑,因为这样的函数没有严酷的类型安全检查.如printf.
  

内存管理

• 栈上开辟空间一定要明确知道空间大小,因为要压栈
  
• 为什么必要动态内存,满足内存申请的机动性
  
• 临时变量为什么有临时性,原因是栈空间本身就具有临时性
  
• 全局数据区,随着整个程序的运行而一直存在; 生存在全局数据区的变量的声明周期都随进程
  
• 我们能检查指针的合法性吗?
  不能;指针如果有详细的指向(包括野指针),对应的合法性我们无法验证,因为指针指向什么用户无法得知;
  一般的合法性检查指的是空指针问题,传入一个错误的非空指针(野指针)是无法检查出来的,只能从编程规范去控制.编码规范约定野指针必要置空,便于进行合法性检查.如果不置空,就是不遵循编码规范
  
• 指针在遍历时,越界不一定会报
  
• 什么样的程序最怕内存走漏? 常驻进程:常驻内存的程序,比方操作系统,杀毒软件,服务器等.
  
• 运行起来的程序,已经和编译器没有关系了
  

malloc返回给用户的只有申请内存的起始地址,那free是怎样准确开释动态内存申请的空间?

从内存查看malloc和free的行为:
malloc,查看内存,内存值为cd的是开辟给用户的空间
(VS中malloc分配的空间会初始化成十六进制cd)

再看free,free后可以发现开释的空间不止10个,说明malloc分配的空间不止10个

内存级cookie

​    申请多出来的空间,是编译器用来记录申请空间的详细数据.提供给free,可以或许实现准确开释申请的内存,一般情况,这些数据的大小是固定的
记录这些信息的数据,称为cookie.属于内存级的cookie
有cookie存在,会有一个内存申请多大问题.申请空间越大好还是越小好?

• 从利用率来说,申请大空间好,因为cookie是固定大小的,如果申请的空间过小,则可利用空间占据总申请空间比率就会小.
  
• 如果想申请小空间,则在栈上申请更高效.
  

因此,栈和堆在那里申请的问题就可以通过这个思考来决定.
C语言程序地址空间-内存验证

1. #include<stdio.h>
2. #include<stdlib.h>
4. void fun1()
5. {}
7. void fun2()
8. {}
10. int g_val1;
11. int g_val2;
13. int g_val3 = 0;
14. int g_val4 = 0;
16. int main()     
17. {            
19.   int a1 = 0;
20.   int a2 = 0;
21.   static int a3 = 0;
23.   puts("栈区增长方向验证:");
24.   printf("stack Area: &a1=%p\n",&a1);
25.   printf("stack Area: &a2=%p\n",&a2);
27.   puts("堆区增长方向验证:");
28.   int *arr1 = (int*)malloc(sizeof(int)*3);
29.   int *arr2 = (int*)malloc(sizeof(int)*3);
30.   printf("heap Area: arr1=%p\n",arr1);
31.   printf("heap Area: arr2=%p\n",arr2);
33.   puts("未初始化数据区:");
34.   printf("uninitialized data Area: %p\n",&g_val1);
35.   printf("uninitialized data Area: %p\n",&g_val2);
36.   
37.   puts("已初始化数据区:");
38.   printf("initialized data Area: %p\n",&g_val3);
39.   printf("initialized data Area: %p\n",&g_val4);
40.   printf("static data Area: %p\n",&a3);
42.   puts("常量区:");
43.   const char *str = "hello world!";
44.   printf("constant Area: %p\n",str);
46.   puts("代码区:");
47.   printf("main addr: %p\n",main);
48.   printf("code Area: fun1=%p\n",fun1);
49.   printf("code Area: fun2=%p\n",fun2);
50.   //在前面的先注册
52.   return 0;   
53. }   

复制代码

函数栈帧

熟悉相关寄存器

eax：通用寄存器，保留临时数据，常用于返回值
ecx：通用寄存器，保留临时数据，常用于返回值
ebx：通用寄存器，保留临时数据
ebp：栈底寄存器
esp：栈顶寄存器
eip：指令寄存器，生存当前指令的下一条指令的地址

熟悉相关汇编下令

mov:数据转移指令
push:数据入栈，同时esp栈顶寄存器也要发生改变
pop:数据弹出至指定位置，同时esp栈顶寄存器也要发生改变
sub:减法下令
add:加法下令
call:函数调用，1. 压入返回地址 2. 转入目标函数
jump:通过修改eip，转入目标函数，进行调用
ret:恢复返回地址，压入eip，类似pop eip下令
lea: 取地址指令,和mov的区别是取得是地址不是数据

查看函数调用堆栈

通过下面代码举例:

1. #include <stdio.h>
4. int Add(int a, int b)
5. {
6.     return a+b;
7. }
9. int main()
10. {
11.     int x = 0xA;
12.     int y = 0xB;
13.     int z = 0;
14.     z = Add(x,y);
15.     return 0;
16. }

复制代码

F10进入调试,走到main函数快结束位置,当前的调用堆栈:

(如果是vs2013,则可以或许进入到调用main函数的源代码中,vs2019下实行完return后直接结束了,有知道怎么解决的朋友可以评论区分享.)
在调用堆栈中右键勾选显示外部代码,可以看到更详细的调用堆栈

打开后能发现更多的调用堆栈,这可以简单说明main函数也是被调用的.

定义变量时的内存变化和汇编代码

看函数调用过程的汇编代码

ebp-14是变量y的地址,ebp-8是x的地址,即先压入y,再压入x,然后再调用函数
说明:

• 形参实例化的顺序从右向左
  
• 函数的形参在函数调用前就形成
  
• 给没有形参的参数传参也是会定义的(补充验证)
  

函数形成与开释:

从汇编上看,函数自己的栈不包括形参
开释栈帧:

因此,调用函数是有本钱的，本钱体现在时间和空间上，本质是形成和开释栈帧有本钱

末了的ret,恢复返回地址，压入eip，类似pop eip下令;即指令寄存器,恢复到主调函数要实行的下一条指令

末了,可以发现,形参变量是通过push和pop管理,那么它们的地址就是一连的.
根据这个原理,我们理论上也可以通过盘算指针偏移量来修改形参的值,来实现一些功能....
现代编译器为了保证程序安全可能有各种安全手段,如栈随机化的技能,金丝雀栈保护机制,因此根据地址直接修改程序没有那么简单.

在进程中,堆栈地址是从高到低分配的.当实行一个函数的时候,将参数列表入栈,压入堆栈的高地址部分,然后入栈函数的返回地址,接着入栈函数的实行代码,这个入栈过程,堆栈地址不断递减,一些黑客就是在堆栈中修改函数返回地址,实行自己的代码来达到实行自己插入的代码段的目的.

可变参数列表

可变参数的原理

​        在函数栈帧的汇编分析中可知,函数形参在函数调用前定义,参数之间位置相对固定,且定义顺序从右往左,依次压栈.
​        因为是可变参数,如果要我们利用,我们只要知道函数形参的第一个形参的起始地址,然后根据每个参数的类型,得到它们的内存空间布局就可以利用了.

可变参数至少必要固定一个形参,否则会报错,为什么?

在C语言中，可变参数函数设计上要求至少有一个固定参数的原因重要有以下几点：

• 标示参数开始：可变参数函数至少必要一个非可变参数作为“标记”，这是因为编译器必要知道从那里开始解析可变参数列表。这个固定参数通常用于传递关于可变参数的信息，比如参数的数目大概某种类型的标识符。比方，在printf函数中，第一个固定参数（格式化字符串）就告诉函数接下来的可变参数应该怎样被解释和处理。
  
• 获取参数信息：通过这个固定的参数，可以在运行时决定怎样访问和解析后面的可变参数。比方，通太过析格式化字符串，printf可以确定必要读取多少个参数以及它们的类型。
  
• 定位参数地址：在实现上，可变参数是通过栈传递的，第一个固定参数的地址可以帮助确定可变参数在栈上的起始位置。这样，通过指针算术，我们可以从这个已知位置开始访问后续的可变参数。
  
• 类型安全与边界界定：虽然C语言本身并不直接支持类型安全检查，但至少有一个固定参数可以作为编写安全、有效的可变参数处理逻辑的底子。这个参数可以辅助进行根本的参数验证，尽管更复杂的类型检查通常必要在函数内部手动实现。
  

简而言之，这个固定的参数不仅是逻辑上的必要，也是技能实现上的必要条件，它帮助程序精确地识别和处理随后的可变数目的参数。在实际应用中，通常会联合头文件中定义的宏（如va_start, va_arg, va_end等）来遍历和处理可变参数列表。

原理是这样,但如果要我们手动去做,显然是一件非常麻烦的事情.
因此C语言提供了一套方案,提供了几个宏便于用户更方便地利用可变参数列表.


C语言提供的可变参数方案

stdarg.h

在stdarg.h文件中有如下几个宏定义：

1. #include <vadefs.h>
3. #define va_start _crt_va_start
4. #define va_arg _crt_va_arg
5. #define va_end _crt_va_end
7. #endif  /* _INC_STDARG */

复制代码

其定义在vadefs.h中分别为：

1. //ap ~= arg
2. //va_list == char*
3. //_ADDRESSOF ~= 取地址
4. //v  ~= num
5. //结合下一小节的简单可变参数程序源码
7. #define _INTSIZEOF(n)          ((sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1))
8. /* 为什么需要对齐
9. 在可变参数函数的参数传参过程中,参数会发生整型提升,因此可变参数函数内部要能够对发生整型提升的参数进行正确的提取,需要进行对齐
10. */
11. //计算对齐后n的大小,例如计算char,四字节对齐,则_intsizeof char为4;
12. //四字节对齐,如果size是1,2,3,4,则对齐size都是4. 如果size是5,6,7,8,则对齐size都是8.依次类推
13. //想要一个数是2,4,8,2^n的倍数,只要&上 对应2^n的二进制的1所在左边为全零,保证左边消除尾数,右边全1,保证右边数位不变 这样的数即可. 即& ~(2^n - 1).  这里2^n整体表示2的倍数,如2,4,8,16....
16. #define _ADDRESSOF(v)          (&(v)) //计算v的地址
18. #define __crt_va_start_a(ap, v) ((void)(ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v)))
19. // va_start : ap=(char*)&num + intsizeof(num);
21. #define __crt_va_arg(ap, t)     (*(t*)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)))
22. //1.ap先指向下一个可变参数:ap += _intsizeof(t)
23. //2.通过ap找到上一个可变参数的地址: ap - _intsizeof(t)
24. //3.解引用,获取上一个可变参数的值: *(t*)ap
28. #define __crt_va_end(ap)        ((void)(ap = (va_list)0))// 将指针置为无效

复制代码

va_list

用于定义可以访问可变参数部分的变量

1. va_list arg; //定义一个指向可变参数的指针变量

复制代码

va_list是char*类型的指针,可以按一字节的方式进行字节级别的数据读取.

1. typedef char* va_list;

复制代码

va_start

1. void va_start(va_list arg_ptr,prev_param);//(ANSI version)
2. //prev_param是可变参数部分的前一个参数,(不需要确定类型,最终会交给intsizeof计算)

复制代码

它可以通过第一个参数来定位可变参数的位置,使arg指向可变参数部分
va_arg

1. type va_arg( va_list arg_ptr, type );
2. //

复制代码

通过arg,和类型,返回对应的值
va_end

arg利用完毕后,使arg指向NULL. 即收尾工作
简单的可变参数程序

1. #include <stdio.h>
2. #include <stdarg.h>
4. int FindMax(int num, ...)
5. {
6.     va_list arg;
7.     va_start(arg, num);
8.     int max = 0;
9.     max = va_arg(arg, int);
10.     for (int i = 0; i < num - 1; i++)
11.     {
12.         int cur = va_arg(arg, int);
13.         if (cur > max)
14.         {
15.             max = cur;
16.         }
17.     }
18.     va_end(arg);
20.     return max;
21. }
23. int main()
24. {
25.     int max = FindMax(5,0x11,0x21,0x31,0x41,0x51);
26.     printf("max = %d\n", max);
27.     return 0;
28. }

复制代码

可变参数的反汇编与内存分析

看可变参数的内存布局和汇编代码,用十六进制作为参数容易看内存
插入前:

插入了一个形参

再看可变参数函数的几个宏:

定位到第一个可变参数的地址后,然后再这个地址赋值给arg,使arg指向第一个可变参数,这就是va_start的本质
再看va_arg:

va_arg可以分为两部分,第一个部分根据类型确定大小,然后将arg指向下一个可变参数.第二部分是取第二个参数的地址,往回指向,找到第一个参数,再将其赋值给max
即va_arg先指向第二个可变参数,再根据第二个可变参数找到一个参数赋值给max
再看va_end:

va_end比较简单,直接指向空.
可变参数整型提拔的反汇编分析

看传char类型触发整型提拔,movsx,带符号扩展(整型提拔),并传送
​        可变参数列表传入参数是char,short,float等类型时,也会发生整型提拔,因为也是要加载到寄存器中
先看直接利用字符的情况

说明字符字面值在盘算时是以整型形式表示的
再看用char变量表示的:

数据传送指令MOV的变体。带符号扩展，并传送。这句指令就是整型提拔的本质,提拔到符合寄存器的大小
留意事项

• 可变参数必须从头到尾逐个访问。如果你在访问了几个可变参数之后想半途终止，这是可以的，但是，如果你
  想一开始就访问参数列表中间的参数，那是不行的。
  
• 参数列表中至少有一个命名参数。如果连一个命名参数都没有，就无法利用va_start。
  
• 这些宏是无法直接判定实际存在参数的数目。
  
• 这些宏无法判定每个参数的是类型。
  
• 如果在va_arg中指定了错误的类型，那么厥后果是不可预测的。
  

留言

1. 如有不足的地方欢迎大家评论区留言指正。

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。