为什么这种C语言中的函数重载方法有效？

Question

我已经查看了一些用C语言做的方法,但我只找到了C99.

但我遇到了以下解决方案,取自Lock Less.

问题是,我不太明白它是如何工作的,并且想知道那里发生的事情的基本原理,以便能够更清楚地理解它.

我已经在网上找了一段时间,发现这个关于__VA_ARGS__,但不幸的是,仅此一点还不够.

我真的很感激有关此问题的解释或指导,任何形式的参考都会有所帮助.

我用GCC-5.4.1和-ansi标志编译了这段代码.

#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>

#define COUNT_PARMS2(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _, ...) _
#define COUNT_PARMS(...)\
    COUNT_PARMS2(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

void count_overload1(int p1)
{
    printf("One param: %d\n", p1);
}

void count_overload2(double *p1, const char *p2)
{
    printf("Two params: %p (%f) %s\n", p1, *p1, p2);
}

void count_overload3(int p1, int p2, int p3)
{
    printf("Three params: %c %d %d\n", p1, p2, p3);
}

void count_overload_aux(int count, ...)
{
    va_list v;
    va_start(v, count);

    switch(count)
    {
        case 1:
        {
            int p1 = va_arg(v, int);
            count_overload1(p1);
            break;
        }

        case 2:
        {
            double *p1 = va_arg(v, double *);
            const char *p2 = va_arg(v, const char *);
            count_overload2(p1, p2);
            break;
        }

        case 3:
        {
            int p1 = va_arg(v, int);
            int p2 = va_arg(v, int);
            int p3 = va_arg(v, int);
            count_overload3(p1, p2, p3);
            break;
        }

        default:
        {
            va_end(v);

            printf("Invalid arguments to function 'count_overload()'");
            exit(1);
        }
    }

    va_end(v);
}
#define count_overload(...)\
    count_overload_aux(COUNT_PARMS(__VA_ARGS__), __VA_ARGS__)


int main(int argc, char const *argv[])
{
    double d = 3.14;
    count_overload(1);
    count_overload(&d, "test");
    count_overload('a',2,3);
    return 0;
}

输出是:

One param: 1
Two params: 0x7ffc0fbcdd30 (3.140000) test
Three params: a 2 3

Answer 1

让我们分解COUNT_PARMS和COUNT_PARMS2宏.第一COUNT_PARMS:

#define COUNT_PARMS(...)\
    COUNT_PARMS2(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

由于宏不包含任何命名参数,因此将传递给它的任何参数代替__VA_ARGS__.

以下是来电:

COUNT_PARMS(arg1)
COUNT_PARMS(arg1, arg2)
COUNT_PARMS(arg1, arg2, ,arg3)

将扩展为:

COUNT_PARMS2(arg1,   10,    9,  8, 7, 6, 5, 4, 3, 2, 1)
COUNT_PARMS2(arg1, arg2,   10,  9, 8, 7, 6, 5, 4, 3, 2, 1)
COUNT_PARMS2(arg1, arg2, arg3, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
                                                  // x

我将参数间隔开,以便您可以看到哪些参数彼此对应.特别注意标记的列x.这是传递给的参数数量COUNT_PARMS,它是每种情况下的第11个参数.

现在让我们来看看COUNT_PARMS2:

#define COUNT_PARMS2(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _, ...) _

有11个名称参数,加上...可以解释任何其他参数.宏的整个主体是_第11个参数的名称.所以这个宏的目的是获取11个或更多的参数,并用第11个参数替换它们.

再看一下它的定义COUNT_PARAMS,它以这样的方式扩展,即它调用COUNT_PARMS2第11个参数是传递给的参数的数量COUNT_PARAMS.这就是神奇的发生.

现在看一下函数调用main:

count_overload(1);
count_overload(&d, "test");
count_overload('a',2,3);

这些扩展到:

count_overload_aux(COUNT_PARMS(1), 1);
count_overload_aux(COUNT_PARMS(&d, "test"), &d, "test");
count_overload_aux(COUNT_PARMS('a',2,3), 'a',2,3);

然后这个:

count_overload_aux(COUNT_PARMS2(1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1), 1);
count_overload_aux(COUNT_PARMS2(&d, "test", 10, 9, 8, 7, 6, 5, 4, 3, 2, 1), &d, "test");
count_overload_aux(COUNT_PARMS2('a',2,3, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1), 'a',2,3);

然后这个:

count_overload_aux(1, 1);
count_overload_aux(2, &d, "test");
count_overload_aux(3, 'a',2,3);

最终结果是你可以调用一个带有可变数量参数的函数,而不必明确说明有多少参数.