在以前的博文中，写过类似的课题。使用的是下面这种方法。
// 递归出口
template <typename T>
void logOld(const T& t)
{
std::cout << t << ‘\n‘;
}
// 递归展开
template <typename T, typename ... Args>
void logOld(const T& t, const Args& ... args)
{
std::cout << t << ‘ ‘;
logOld(args...);
}
函数调用有递归，模板在展开的时候也可以有递归。在写递归函数时，我们需要找出递归的出口，这么不会陷入无限递归。同样，在运用模板展开时候递归同样需要考虑递归的出口。
为了实现随意log的输出，比如
zz::logOld(1);
zz::logOld(1, 2);
zz::logOld(1, 2, ‘-‘, "Today");
int a[4];
zz::logOld("Hello", "World", 2016, ‘-‘, 3, ‘-‘, 19, a);那么参数就是不可控的，但是在递归展开中，最后一个参数，肯定是递归的出口，如上面logOld函数定义所示。运行的效果：
但是，这种是递归实现，生成的代码也是嵌套的，性能方面有所损失，但是现实起来方便也很容易理解。
最近看了一些文章，关于可变参数模板的，有一些关于Parameter pack的文章，其中有关于Pack expansion的使用。
>
Pack expansio
A pattern followed by an ellipsis, in which the name of at least one parameter pack appears at least once, is expanded into zero or more comma-separated instantiations of the pattern, where the name of the parameter pack is replaced by each of the types from the pack, in order.
其就是提供一种多参数解包的模式，模式必须含有至少一个参数。
根据这个特性，我设计了以下的代码
template <typename T>
typename std::decay<T> unpack(const T& t)
{
std::cout << t << ‘ ‘;
typename std::decay<T> _ins;
return _ins;
}
template <typename T, typename ... Args>
void debugLogImpl(const T& t, const Args& ... args)
{
std::cout << t << ‘ ‘;
auto _fun = [](...) {};
_fun(unpack(args)...);
std::cout << ‘\n‘;
}unpack为解包一个参数的模式，unpack(args)…介绍多参数。
比如args为a，b，c，那么unpack(args)…等价于unpack(a), unpack(b), unpack(c)。这种形式的解包结果，我现在只想到了作为函数参数。所有我定义了一个lambda函数，其接受多参数，然后调用这个lambda函数来调用解包之后的unpack函数集合。
但是函数参数入栈的顺序是从右往左，那么先调用的是unpack(c)，输出的也就是”c”，那么不行的。但是在C++14中我们可以直接
(unpack(args), ...);但是在C++11中，这是不可以的。我也没有找出这么顺序调用解包之后的函数的办法。为了解决这个log顺利不对的问题，无奈又写了一大段的特例模板。
template <typename T>
typename std::decay<T> unpack(const T& t)
{
std::cout << t << ‘ ‘;
typename std::decay<T> _ins;
return _ins;
}
template <typename T, typename ... Args>
void debugLogImpl(const T& t, const Args& ... args)
{
std::cout << t << ‘ ‘;
auto _fun = [](...) {};
_fun(unpack(args)...);
std::cout << ‘\n‘;
}
template <typename T0>
void debugLog(const T0& t0)
{
debugLogImpl(t0);
}
template <typename T0, typename T1>
void debugLog(const T0& t0, const T1& t1)
{
debugLogImpl(t0, t1);
}
template <typename T0, typename T1, typename T2>
void debugLog(const T0& t0, const T1& t1, const T2& t2)
{
debugLogImpl(t0, t2, t1);
}
template <typename T0, typename T1, typename T2, typename T3>
void debugLog(const T0& t0, const T1& t1, const T2& t2, const T3& t3)
{
debugLogImpl(t0, t3, t2, t1);
}
...
template <typename T0, typename T1, typename T2, typename T3, typename T4
, typename T5, typename T6, typename T7, typename T8, typename T9>
void debugLog(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4
, const T5& t5 ,const T6& t6, const T7& t7, const T8& t8, const T9& t9)
{
debugLogImpl(t0, t9, t8, t7, t6, t5, t4, t3, t2, t1);
}
将参数调个个。
#define DEBUG_LOG(...) zz::debugLog(__VA_ARGS__)
定义一个宏，来统一对外口径。
int main()
{
// zz::logOld(1);
// zz::logOld(1, 2);
// zz::logOld(1, 2, ‘-‘, "Today");
// int a[4];
// zz::logOld("Hello", "World", 2016, ‘-‘, 3, ‘-‘, 19, a);
DEBUG_LOG(1);
DEBUG_LOG(1, 2);
DEBUG_LOG(1, 2, 3);
DEBUG_LOG(1, ‘-‘, ‘a‘, 1, "sssss");
return 0;
}结果如下
然后就是
template <typename T>
typename std::decay<T> unpack(const T& t)
{
std::cout << t << ‘ ‘;
typename std::decay<T> _ins;
return _ins;
}
这边为什么要用decay，如果不用向这样
template <typename T>
T unpack(const T& t)
{
std::cout << t << ‘ ‘;
return t;
}
对于这样的“ssssss”，其会报
/home/zhou/work/qt_project/zzLog/main.cpp:48: error: no matching function for call to ‘unpack(const char [6])‘
_fun(unpack(args)...);
---
/home/zhou/work/qt_project/zzLog/main.cpp:36: error: function returning an array
^使用decay将数组退化为const char*来解决问题。