将数组的所有元素传递给具有可变参数的函数 (...)

Question

我需要将可变数量的参数传递给允许可变数量参数的 c 函数。

function a(int n , ...) {...} //*n* number of parameters

int b[XXX]; //XXX is more or less run-time dynamic.
//Filsignals.https://github.com/libpd/libpd/blob/master/pure-data/src/d_ugen.cl b with things.
a(n, b[0], b[1] ... b[XXX])

如何在不命名 b 的每个元素的情况下编写此代码？

一件事：我无法更改它的实现a()，它使用va_list访问“...”。因此，我无法传递“b”，因为“b”只能作为一个a(n, b)参数处理，但它包含更多参数。

更多细节：a() 实际上是 puredatadsp_add()函数（在 中定义d_ugen.c），它使用传递的指针来设置传入和传出。

一种选择

我刚刚发现可以通过使用来避免这个问题dsp_addv()，它是可变参数函数的数组版本dsp_add()。

然而，这并不能回答我的问题......

Answer 1

您已经找到了问题的答案。我认为使用该函数的数组变体是正确的方法。（对该dsp_addv函数的评论很能说明问题。）

然而，这并不能回答我的问题......

根据可变参数函数的性质，您可以编写一个调用可变参数函数的包装函数。这并不适用于所有情况，但适用于某些常见情况。（可变参数函数本身在使用上受到相当的限制。在某个地方，我读到过一种说法，它们的存在只是为了实现printf。）

迭代

对每个可变参数都做了一些处理：例如，将其打印出来，或者将其添加到列表中。在这种情况下，您可以为每个参数调用该函数：

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

void varg_print(const char *str, ...)
{
    va_list va;

    va_start(va, str);
    while (str) {
        puts(str);
        str = va_arg(va, const char *);
    }
    va_end(va);
}

void arr_print(const char **str)
{    
    while (*str) varg_print(*str++, NULL);
}

int main()
{
    const char *fruit[]) = {"apple", "pear", "banana", NULL};
    arr_print(fruit);

    return 0;
}

减少

所有参数都减少为单个值，例如它们的总和或最大值。在这里你可以处理子数组，直到得到你想要的。下面的示例将数组一次最多转发四个元素到求和函数，并用结果覆盖数组的较低区域，直到只剩下一个值。

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

double varg_sum(int n, ...)
{
    double s = 0.0;
    va_list va;

    va_start(va, n);
    while (n--) s += va_arg(va, double);
    va_end(va);

    return s;
}

double arr_sum(int n, double *x)
{
    double r[n];

    if (n <= 0) return 0.0;

    memcpy(r, x, n * sizeof(*x));

    while (n > 1) {
        double *p = r;
        int m = 0;

        while (n) {
            switch (n) {
            case 1:     r[m++] = varg_sum(1, p[0]);
                        n -= 1;
                        p += 1;
                        break;

            case 2:     r[m++] = varg_sum(2, p[0], p[1]);
                        n -= 2;
                        p += 2;
                        break;

            case 3:     r[m++] = varg_sum(3, p[0], p[1], p[2]);
                        n -= 3;
                        p += 3;
                        break;

            default:    r[m++] = varg_sum(4, p[0], p[1], p[2], p[3]);
                        n -= 4;
                        p += 4;
                        break;
            }
        }

        n = m;   
    }

    return r[0];
}

int main()
{
    double x[100];
    int i;

    for (i = 0; i < 100; i++) x[i] = i + 1.0;
    printf("%g\n", arr_sum(100, x));   

    return 0;
}

该代码复制了数组，这样原始数组就不会被破坏。您可以增加块大小以便更有效地处理更大的数组，但是可变参数函数并不是为长可变参数列表设计的，所以四个似乎没问题。