C语言深度探究具有不定参数的函数-阿里云开发者社区

C语言深度探究具有不定参数的函数

✨博主介绍

前言

C语言 stdarg.h

示例

ta的原理

函数传参数的本质

_INTSIZEOF(n)

其他宏

练习实现printf

💫点击直接资料领取💫

✨博主介绍

💂 个人主页:苏州程序大白

💂 个人社区:CSDN全国各地程序猿

🤟作者介绍：中国DBA联盟(ACDU)成员，CSDN全国各地程序猿（媛）聚集地管理员。目前从事工业自动化软件开发工作。擅长C#、Java、机器视觉、底层算法等语言。2019年成立柒月软件工作室，2021年注册苏州凯捷智能科技有限公司

💅 有任何问题欢迎私信，看到会及时回复

👤 微信号：stbsl6，微信公众号：苏州程序大白

💬如果文章对你有帮助，欢迎关注、点赞、收藏（一键三连）

🎯 想加入技术交流群的可以加我好友，群里会分享学习资料

前言

C语言虽然不支持泛型编程（至少C98是这样的），但是C语言却支持不定参数的函数，这里我深究一下里面的原理，并且学会它的使用，自己简单实现一个简单的printf函数。注：这里使用的IDE为 vs2022

至于如何实现不定参数的函数呢？这里可以看一下标准库是如何定义的：

    _Check_return_opt_
    _CRT_STDIO_INLINE int __CRTDECL printf(
        _In_z_ _Printf_format_string_ char const* const _Format,
        ...)

这里char const* const _Format ,显然就是我们传入格式字符串，后面出现了 …,这个类型没见过，那它应该是实现可变参数的关键了。在C语言中… 三点就表示不定参数，这里我们又遇到了一个新的问题，传入了不定参数之后如何拿出不定参数？使用几个宏就完成这一个操作，没错就是宏。

C语言 stdarg.h

定义

在了解 ta的原理之前，还是学会如何使用ta。

宏描述

void va_start(va_list ap, last_arg) 这个宏初始化 ap 变量，使ap指向起始的参数(last_arg)

type va_arg(va_list ap, type) 获取下一个类型为type的参数

void va_end(va_list ap) 释放ap

va_copy(destination, source) 拷贝ap的内容

提示：va_start va_arg va_end 务必按照此顺序使用

示例

光看这个表格实在是难以理解还是实操一个吧。

#include<stdio.h>
#include<stdarg.h>
//实现 args_nums个int类型的数相加
int sum(int args_num, ...)
{
    va_list ap;
    int sum = 0;
    va_start(ap, args_num);//1. 初始化 ap 
    for (; args_num > 0; --args_num)
        sum += va_arg(ap, int);//2. 获取 下一个int类型的参数
    va_end(ap);//结束使用
    return sum;
}
int main()
{
    printf("sum: %d", sum(5, 1, 2, 3, 4, 5));
    return 0;
}

仔细阅读该程序，我们可以大致了解ta的基本使用

1、va_start(ap, args_num) 初始化ap。

2、va_arg(ap, int) 获取下一个int类型参数。

3、va_end(ap) 结束使用。

4、补充：stdarg.h 并没有提供帮我们判断不定参数有多个的方法，这里我是用传入一个args_num来标记有多个不定参数，不要以为我们必须传入一个int来标记，我们可以采取其他方法的（后面补充）。

5、这里我们必须传入一个确定的参数作为第一个参数，因为 va_start 需要一个确定的参数初始化。

运行结果：

ta的原理

函数传参数的本质

C语言是最接近汇编的一门语言，函数传参的本质到底是什么，简单一句话 ——将参数压栈，如何你有汇编的经历的话，就知道如果要给一个过程传入参数就需要你提前将传入的参数压入栈中，C语言就是这样做的，当然控制压栈这么麻烦的操作编译器在编译的过程中就帮你完成了。当然这要拿出汇编中的一个知识点，每次压栈和出栈的基本单位不是字节，而是当前CPU的字长为单位的，比如 32位那么每次压栈就是以4字节位基本单位的。

现在我们研究一下，多个参数的压栈顺序，是从左到右还是反之？

#define VNAME(val) (#val) // 获取val变量的名字
typedef struct test { char c[6]; } test; //定义结构体 test
void foo(test a, char b,int c )
{
    printf("%s addr: %p\n",VNAME(a),&a);
    printf("%s addr: %p\n", VNAME(b), &b);
    printf("%s addr: %p\n", VNAME(c), &c);
}
int main()
{
    test t = { "123456" };
    foo(t, 2, 3);
    return 0;
}

补充：C程序栈底为高地址，栈顶为低地址。

在X86的环境下，我们在第8行打入断点，使用内存查看工具查看内存。

我们发现大小只有 1字节的b都占了4字节的大小，大小为6的a占了8字节，这一点是万确适应前面所说的 32位那么每次压栈就是以4字节位基本单位的，如果是64为的话，那么char一定会占8字节。

输出：

我们发现下从 c到 a地址越来越小，说明c先入栈，后面才进b和a, 得出结论 C语言函数参数入栈顺序为从右至左。

如果我们得到了第一个参数的地址，那么我们可以根据参数的所占空间来确定下一个参数的地址，那么我们不就是获取了下一个参数的值了吗？C语言也是这样想的。例如：知道 a的地址为 010FFAA4 ，A所占空间为8，那么b的地址一定为 &a+8。

我们简单验证一下：更具 a的地址获取 b和c的值。

    char* p = &a;
    char bb = *(char*)(p += 8);
    int cc = *(int*)(p += 4);
    printf("b : %d,c : %d\n", bb, c);

这里强调一点的是，咱们使用 p 为char*，原因很简单，如果是其他类型指针如 int ,那么 p+8 却偏移了48=32字节位置，而不是 8字节。那么我有理由相信 va_list就是 char

我们这个唯一的缺点就是只解决这一个函数的特例，无法自定义，如果有函数可以帮我们求出偏移量就好了。

这里我们就解开庐山真面目，看看标准库是如何定义他们的。（这里经过了多次跳转）。

    typedef char* va_list;   //和我想得一样
  #define _INTSIZEOF(n)          ((sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1)) //求n类型 在栈中所占空间
    #define __crt_va_start_a(ap, v) ((void)(ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v))) //初始化 ap
    #define __crt_va_arg(ap, t)     (*(t*)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)))//获取下一个变量
    #define __crt_va_end(ap)        ((void)(ap = (va_list)0))//结束使用ap
  #define va_copy(destination, source) ((destination) = (source))//拷贝

这里我们单独解释一下每个宏原理。

_INTSIZEOF(n)

#define _INTSIZEOF(n)          ((sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1))

_INTSIZEOF(n)整个做的事情就是将n的长度化为int长度的整数倍,比如n为5，二进制就是101b，int长度为4，二进制为100b，那么n化为int长度的整数倍就应该为8。换一句话说它就帮我们求出变量间的偏移量。

~是位取反的意思。~(sizeof(int) – 1) )就应该为~（4-1）=~（00000011b）=11111100b，这样任何数& ~(sizeof(int) – 1) )后最后两位肯定为0，就肯定是4的整数倍了。(sizeof(n) + sizeof(int) – 1)就是将大于4m但小于等于4（m+1）的数提高到大于等于4（m+1）但小于4(m+2)（m为0,1,2,…），这样再& ~(sizeof(int) – 1) )后就正好将原长度补齐到4的倍数了。

MSVC是这样实现的，我们可以看看 GNUC是如何实现的：

#define __va_rounded_size(TYPE)  \  //名字虽然不一样但是功能是一样的，毕竟这是不同的厂家
  (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))

显然这个更容易理解一些，(sizeof (TYPE) + sizeof (int) - 1)/ sizeof (int)求得type所占空间至少为 int类型的多少整数倍，再乘以4刚好实现了长度补齐到4的倍数。比如__va_rounded_size(char)= ((1+3)/4)4= 4。

个人感觉 MSVC的效率更好一点，毕竟是逻辑运算，当然GNUC的方法更加容易理解，我研究微软的实现方式还是花了不少的时间的。

其他宏

剩下三个宏，非常容易理解，我就不在解释了，大伙可以对照实验和定义，很快你就会明白其中的奥义。

练习实现printf

这里我们仅仅只是练习多个参数的传递而不是深入底层地实现printf这个函数，如果你愿意可以去看看 vprintf的实现，有非常多的奥秘值得探究。

这里放出我的代码，非常小儿科。

#include<stdio.h>
#include<stdarg.h>
int myPrintf(const char* string, ...);
int main()
{
    //printf("sum: %d", sum(5, 1, 2, 3, 4, 5));
    myPrintf("helloworld%d%s%c\na", 15, "122", 'z');
    return 0;
}
//大致思路 将string 中的 %d %c \n 等 替换成 对应的字符 存储再 buffer中
//这里只实现了 %d %c %s \n
int myPrintf(const char* string, ...)//返回实际输出字符个数
{
    char buffer[BUFSIZ];
    int temp = 0;
    va_list arg;
    char* p_string = NULL;
    char* p_buffer = buffer;
    char* p_temp = NULL;
    int counter = 0;//输出字符长度
    int number = 0;
    int foo = 0;
    va_start(arg, string);
    for (counter = 0, p_string = string; *(p_string) != '\0';)
    {
        switch (*p_string)
        {
        //处理 %
        case '%':
        {
            switch (*++p_string)
            {
            case 'd':
                temp = va_arg(arg, int);
                foo = temp;
                //获取 位数
                while (foo)
                {
                    number++;
                    counter++;
                    foo /= 10;
                }
                foo = temp;
                //整数转字符串
                while (number)
                {
                    *(p_buffer + number - 1) = (foo % 10)+'0';
                    foo /= 10;
                    number--;
                }
                p_buffer += number;
                break;
            case 'c':
                temp = va_arg(arg, int);
                *(p_buffer++) = temp;
                break;
            case 's':
                p_temp = va_arg(arg, char*);
                while (*p_temp !='\0')
                {
                    *(p_buffer++) = *(p_temp++);
                    counter++;
                }
                break;
            default:
                break;
            }
            ++p_string;
            break;
        }
        //处理 转移字符
        case '\\':
        {
            p_string++;
            switch (*p_string)
            {
            case 'n':
                *(p_string++) = '\n';
                break;
            default:
                break;
            }
            break;
        }
        default:
            *(p_buffer++) = *(p_string++);
            counter++;
        }
    }
    *(p_buffer++) = '\0';
    va_end(arg);
    p_buffer = NULL;
    puts(buffer);
    return counter;
}

C语言深度探究具有不定参数的函数