void a(...)
{
  // some stuff ...
}

void b(...)
{
  // тут хочу вызвать a(...) с теми же аргументами
}

void av(va_list args)
{
  // do stuff using va_arg macro
}

void a(...)
{
  va_list args;
  va_start(args, 0); // тут не уверен что ноль,
                     //  возможно, работает только для функций с 1+ аргументами,
                     //  т.е. должен быть хоть один именованный аргумент
  av(args);
}

void b(...)
{
  va_list args;
  va_start(args, 0);
  av(args);
}

void av(va_list args)
{
  // do stuff using va_arg macro
}

_>void a(...)
_>{
_>  // some stuff ...
_>}

_>void b(...)
_>{
_>  // тут хочу вызвать a(...) с теми же аргументами
_>}
_>

template<typename... T>
void a(T... v)
{
    //...
}

template<typename... T>
void b(T... v)
{
    a(v...);
}

_>void a(...)
_>{
_>  // some stuff ...
_>}

_>void b(...)
_>{
_>  // тут хочу вызвать a(...) с теми же аргументами
_>}
_>

//Здесь указатели
void a(int* b...)
{
    std::cerr<<*b<<std::endl;
    ++b;
    std::cerr<<*b<<std::endl;
    ++b;
    std::cerr<<*b<<std::endl;
}

//Здесь значения:
void b(int i...)
{
    int * ptr = &i;

    std::cerr<<*ptr<<std::endl;
    ++ptr;
    std::cerr<<*ptr<<std::endl;
    ++ptr;
    std::cerr<<*ptr<<std::endl;

    a(&i);
}

int main(int argc, char* argv[])
{

int i = 15;
int i2 = 99;
int i3 = 999;

b( i, i2, i3);

}

A>template<typename... T>
A>void a(T... v)
A>{
A>    //...
A>}

A>template<typename... T>
A>void b(T... v)
A>{
A>    a(v...);
A>}
A>

A>

template <typename ... Args>
auto b(Args && ... args) -> decltype(a(std::forward<Args>(args) ...))
{
    return a(std::forward<Args>(args) ...);
}

The general form of the forwarding problem is that in the current language,

For a given expression E(a1, a2, ..., an) that depends on the (generic) parameters a1, a2, ..., an, it is not possible to write a function (object) f such that f(a1, a2, ..., an) is equivalent to E(a1, a2, ..., an).

If an expression initially has the type “rvalue reference to T” (8.3.2, 8.5.3), the type is adjusted to “T” prior to any further analysis, and the expression designates the object or function denoted by the rvalue reference. If the expression is the result of calling a function, whether implicitly or explicitly, it is an rvalue; otherwise, it is an lvalue.

The result of the expression static_cast<T>(v) is the result of converting the expression v to type T. If T is an lvalue reference type, the result is an lvalue; otherwise, the result is an rvalue.

template <class T>
    void f(T &&t)
        { E(t); }

struct X {};

void E(A &&)      { std::cout << "E(A &&)\n"; }
void E(A const &) { std::cout << "E(A const &)\n"; }

template <class T>
    void f(T &&t)
        { E(t); } // t is lvalue

int main()
{
    E(A()); // calls E(A &&)
    f(A()); // calls E(A const &)
}

struct A {};

void E(A &&)      { std::cout << "E(A &&)\n"; }
void E(A const &) { std::cout << "E(A const &)\n"; }

template <class T>
    void f(T &&t)
        { E(std::forward<T>(t)); }

int main()
{
    A a;

    E(a);   // calls E(A const &)

    f(a);   // calls E(A const &)
            // T is deduced to be "lvalue reference to A"
            // f<A &>'s function parameter is "lvalue reference to A"

    E(A()); // calls E(A &&)

    f(A()); // calls E(A &&)
            // T is deduced to be "A"
            // f<A>'s function parameter is "rvalue reference to A"
}

Template argument deduction is done by comparing each function template parameter type (call it P) with the type of the corresponding argument of the call (call it A) as described below.

If P is an rvalue reference to a cv-unqualified template parameter and the argument is an lvalue, the type “lvalue reference to A” is used in place of A for type deduction. [ Example:

template <typename T> int f(T&&);
int i;
int j = f(i);                          // calls f<int&>(i)
template <typename T> int g(const T&&);
int k;
int n = g(k);                          // calls g<int>(k)

—end example ]

If a template-argument for a template-parameter T names a type that is a reference to a type A, an attempt to create the type “lvalue reference to cv T” creates the type “lvalue reference to A,” while an attempt to create the type “rvalue reference to cv T” creates the type T [ Example:

template <class T> class X {
  void f(const T&);
  void g(T&&);
};
X<int&> x1;                 // X<int&>::f has the parameter type int&
                            // X<int&>::g has the parameter type int&
X<const int&&> x2;          // X<const int&&>::f has the parameter type const int&
                            // X<const int&&>::g has the parameter type const int&&

—end example ]

M>template <class T>
M>    void f(T &&t)
M>        { E(std::forward<T>(t)); }