C++中的变量自定义参数列表？

Question

我正在寻找一种简单的方法来创建一个用户多参数接收函数，

下面是一些伪代码

#include <iostream>

struct A {
   int m_num;
};

void function(A* a, ...)
{
    /* Pseudo-Code here */
    for each parameter do 
        print a->m_num
    end
}

int main()
{
   A *a = new A();
   A *b = new A();
   A *c = new A();

   a->m_num = 1;
   b->m_num = 10;
   c->m_num = 100;

   function(a,b,c);

   // delete everything

   return 0;
}

我真的不能在这里使用boost，所以如果可以使用标准C++ (允许使用STL )，那就太好了。

编辑:函数参数是异构的

Answer 1

老式的纯C语言变量参数：

#include <cstdio>
#include <stdarg.h>

struct A {
    A () : m_num (0) {}
    A (int v) : m_num (v) {}
    int m_num;
};

void function (A *a, ...)
{
    va_list ap;
    A *p = a;
    va_start (ap, a);
    while (p != NULL)
    {
        printf ("%d\n", p->m_num);
        p = va_arg (ap, A*);
    }
    va_end (ap);
}

int main()
{
    A a (1), b (10), c (100);
    function (&a, &b, &c, NULL);
}

如果参数是相同类型的另一种解决方案(这就是您的情况)：

#include <cstdio>

struct A {
    A () : m_num (0) {}
    A (int v) : m_num (v) {}
    int m_num;
};

void function (A *p, A *endp)
{
    while (p != endp)
    {
        printf ("%d\n", p->m_num);
        ++p;
    }
}

int main()
{
    A a[3];
    a[0].m_num = 1;
    a[1].m_num = 10;
    a[2].m_num = 100;
    function (a, a + sizeof (a) / sizeof(a[0]));
}

或者更多的C++风格，使用迭代器：

#include <cstdio>
#include <vector>
#include <list>

struct A {
    A () : m_num (0) {}
    A (int v) : m_num (v) {}
    int m_num;
};

template <typename T>
void function (T p, T endp)
{
    while (p != endp)
    {
        printf ("%d\n", p->m_num);
        ++p;
    }
}

int main()
{
    A a[3];
    a[0].m_num = 1;
    a[1].m_num = 10;
    a[2].m_num = 100;
    function (a, a + sizeof (a) / sizeof(a[0]));

    std::vector<A> av (3);
    av[0].m_num = 1;
    av[1].m_num = 10;
    av[2].m_num = 100;
    function (av.begin (), av.end ());

    std::list<A> al;
    al.push_back (A (1));
    al.push_back (A (10));
    al.push_back (A (100));
    function (al.begin (), al.end ());
}

Answer 2

最直接的方法是将参数放入std::vector中。如果它们是非齐次的，你可以使用boost::any或boost::variant的向量。

或者像streams一样设计你的接口，并使用一个插入式的操作符/函数，一次只对一个参数进行操作。

它看起来像这样，交替使用一个朋友的自由函数。

struct A
{
   int m_num;
};

struct printer
{
function& operator<<(A* a)
{
    /* Pseudo-Code here */
    print a->m_num

    return *this;
}
};

int main()
{
   A *a = new A();
   A *b = new A();
   A *c = new A();

   a->m_num = 1;
   b->m_num = 10;
   c->m_num = 100;

   printer function;
   function << a << b << c;

   // delete everything

   return 0;
}

Answer 3

如果进入函数的每个参数都是A，我会用一个A数组来实现，如下所示：

int main() {
  A *abc[3];

  for (int i=0;i<3;i++)
    abc[i]=new A();

  abc[0]->m_num=1;
  abc[1]->m_num=10;
  abc[2]->m_num=100;

  function(abc,3);
}

void function(A *vals[],int count) {
  for (int i=0;i<count;i++)
    print vals[i]->m_num;
}