介绍C++11标准的变长参数模板

//============================================================================
// Name        : CPPTest.cpp
// Author      : Zenny Chen
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include <typeinfo>
using namespace std;
#include <stdio.h>
#include <stdarg.h>

struct MyTest;

// 普通的C函数变长形参
static void MyCPrint(const char *s, ...)
{
    char strBuffer[1024];
    va_list ap;
    va_start(ap, s);
    vsprintf(strBuffer, s, ap);
    va_end(ap);
    printf(strBuffer);
}

template <typename... TS>   // typename... TS为模板形参包，TS为模式
static int MyPrint(const char* s, TS... args)  // TS... args为函数形参包，args为模式
{
    return printf(s, args...);
}

template <typename... TS>    // 模板形参包（template parameter pack）
static void DummyIter(TS... args)    // 函数形参包（function parameter pack）
{
}

template <typename T>
static T Show(T t, int n)
{
    cout << "The value is: " << t << ", and n = " << n << endl;
    return t;
}

template <typename... TS>
static void Func(TS... args)
{
    // 这里，Show(args, sizeof...(args))为模式，因此Show(args, sizeof...(args))...被扩展
    // 每个args实例的类型为其所对应TS模板实参的类型
    // 这里，Show(T, int)函数必须返回T类型，不能是void，由于void与TS...类型无法匹配
    DummyIter(Show(args, sizeof...(args))...);
}

// 请大家注意一下以下两种函数调用方式的不同！
template <typename... Types>
static void Foo(Types... args)
{
    // 对DummyIter调用扩展MyPrint("The type is: %s\n", typeid(args).name())
    DummyIter(MyPrint("The type is: %s\n", typeid(args).name()) ...);
    puts("============");
    // 对MyPrint调用扩展args
    DummyIter(MyPrint("The first value is: %d, second is: %s, third is: %f\n", args...));
}

// 对C++11标准14.5.3条款中的第5项中例子的进一步描述
template <typename... Types>
struct VariadicStruct : Types...
{
    
};

template <typename... Types>
static void ConstructStruct(void)
{
    VariadicStruct<Types...>();
}

template void ConstructStruct<>(void);  // OK：VariadicStruct<>没有基类


template <typename... Types>
static void f(Types... args)
{
    printf("The sample values are: %f, %f\n", args...);
}

// 特化不带任何参数的f
template<> void f<>()
{
    cout << "No arguments!" << endl;
}

template <typename T1, typename T2>
static auto h(T1 t1, T2 t2) -> decltype(t1 * t2)
{
    return t1 * t2;
}

template <typename... Types>
static void g(Types... args)
{
    // 这里，调用main函数中的g(10, 0.1)之后，会被展开为：
    // f(h(10, 0.1) + 10, h(10, 0.1) + 0.1);
    // 这里有两层包展开，首先对于f()，其模式为h(args...) + args
    // 然后对于h()，其模式为args
    // 因此，最右边的省略号其实是对整个(h(args...) + args)进行扩展
    // 其等价于：f((h(args...) + args) ...);
    f(h(args...) + args ...);
}

extern "C" void cppTest(void)
{
    MyCPrint("This is C print: %d, %s\n", 1, "Hello, world!");
    MyPrint("This is my print: %d, %s\n", -1, "Hello, world!");
    
    Func(-100, 0.5);
    
    puts("");
    
    Foo(3, "Hello", 0.25);
    
    // 对C++11标准14.5.3条款中的第5项中例子的进一步描述
    puts("\n");
    struct A{};
    struct B{};
    ConstructStruct<A, B>();    // 在此函数内部构造了VariadicStruct<A, B>
    ConstructStruct<>();        // 在此函数内构造了VariadicStruct<>，它没有基类
    
    g(10, 0.1);
    g<>();
}