Question

I’m looking for a simple way to create a user multi-parameter receiving function,

Here’s some pseudo code

#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;
}

I can’t really use boost here, so if it’s possible with standard C++ ( STL Allowed ), it would be great.

EDIT: The function parameters are heterogeneous

Answer 1

Old school plain C variadic arguments:

#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);
}

Another solution if arguments are of the same type (which is your case):

#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]));
}

Or even more C++-style, with iterators:

#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 ());
}