VarArgs class is a special type of container, eliminating the need for C style variadic functions and related va_xxx macros. It can contain any type of argument in an orderly fashion, and allows dynamic manipulation of the arguments list.

class VarArgs : Moveable<VarArgs> {
    Vector<Any> args;
public:
    template<class T> VarArgs&  Add(const T& t)                 { args.Add().Create<T>() = t; return *this; }
    template<class T> VarArgs&  operator<<(const T& t)          { return Add(t); }
    template<class T> T&        Set(int i, const T& t)          { T& arg = args[i]; arg = t; return arg; }  
    template<class T> T&        Insert(int i, const T& t)       { return args.Insert(i, t); }
    template<class T> T&        Get(int i)                      { ASSERT(Is<T>(i)); return args[i].Get<T>(); }
    inline void                 Remove(int i)                   { args.Remove(i); }
    inline int                  GetCount() const                { return args.GetCount(); }
    inline void                 Clear()                         { args.Clear(); }
    template<class T> bool      Is(int i) const                 { args[i].Is<T>(); }
    inline bool                 IsEmpty() const                 { return args.IsEmpty(); }
    inline bool                 IsPicked() const                { return args.IsPicked(); }     
    
    VarArgs()                   {}
    virtual ~VarArgs()          {}
};

#include <Core/Core.h>
#include <VarArgs/VarArgs.h>

using namespace Upp;

String str_cpp = "This is a demonstration of the VarArgs class of C++!";

bool PrintNumberViaGate(int i) 
{
    Cout() << "Number printed via gate: " << i << "\r\n";
    return false;
}
void Foo(VarArgs& va) 
{
    Cout() << va.Get<int>(0) << "\r\n";
    Cout() << va.Get<float>(1) << "\r\n";
    Cout() << va.Get<String>(2) << "\r\n";

    String* str_upp = va.Get<String*>(3);
    str_upp->Set(str_upp->ReverseFind('C'), 'U');
    Cout() << str_cpp << "\r\n";

    Gate1<int> cb = va.Get<Gate1<int> >(4);
    cb(9999);
}

CONSOLE_APP_MAIN
{
    Foo(VarArgs() << 10 << 22.33f << String("Hello World!") << &str_cpp << callback(PrintNumberViaGate));
//  Same thing can be done via explicit calls.
//  VarArgs va;
//  va  .Add(10)
//      .Add(22.33f)
//      .Add(String("Hello World!"))
//      .Add(&str_cpp)
//      .Add(callback(PrintNumberViaGate));
//  Foo(va);    

}