Question

我正在使用qt，gcc和c ++ 11。

我想要一个以这种方式工作的调试功能：

int a = 1;
float b = 2.2;
QString c = "hello";

用法：

myFunc(a);       // print a 1 
myFunc(a, b);    // print a 1 b 2.2 
myFunc(a, b, c); // print a 1 b 2.2 c hello

我本可以使用一个可变参数模板函数来解决它，但我也需要打印变量名。

只有1个参数这个宏工作正常

#define VAR(var) qDebug() << #var << var;

所以我试图使用variadics宏来解决我的问题：

#define MVAR(...) VAR(__VA_ARGS__)

它适用于1个变量，但是当我尝试更多它时，它给了我“宏VAR通过2个争论，但只需要1”。

我该如何解决？

Answer 1

您正在使用两个参数调用宏VAR，因为__VA_ARGS__扩展为完整的逗号分隔列表。但那个宏只需要一个参数。

您可以做的仍然是使用可变参数模板实现此功能，但使用宏来转发变量名称和值。不幸的是，它需要相当多的样板来合并和拆分可变参数宏参数。我相信Boost有一个用于表达这一点的库，但我从未使用它。

#define EXPAND(x) x
#define COUNT_ARGS(...) COUNT_ARGS_(__VA_ARGS__, COUNT_ARGS_RSEQ())
#define COUNT_ARGS_(...) EXPAND(COUNT_ARGS_N(__VA_ARGS__))
#define COUNT_ARGS_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, N, ...) N
#define COUNT_ARGS_RSEQ() 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0

#define EXPAND_NAME_VALUE(argvalue, argname) argname, argvalue

#define EXPAND_ARGS(how, ...) EXPAND_ARGS_(how, COUNT_ARGS(__VA_ARGS__), __VA_ARGS__)
#define EXPAND_ARGS_(how, N, ...) EXPAND_ARGS__(how, N, __VA_ARGS__)
#define EXPAND_ARGS__(how, N, ...) EXPAND(EXPAND_ARGS_##N(how, __VA_ARGS__))
#define EXPAND_ARGS_1(how, arg, ...) how(arg, #arg)
#define EXPAND_ARGS_2(how, arg, ...) how(arg, #arg), EXPAND(EXPAND_ARGS_1(how, __VA_ARGS__))
#define EXPAND_ARGS_3(how, arg, ...) how(arg, #arg), EXPAND(EXPAND_ARGS_2(how, __VA_ARGS__))
#define EXPAND_ARGS_4(how, arg, ...) how(arg, #arg), EXPAND(EXPAND_ARGS_3(how, __VA_ARGS__))
// ...

#define MVAR(...) Print(EXPAND_ARGS(EXPAND_NAME_VALUE, __VA_ARGS__))

#include <string>
#include <iostream>

template <typename T>
void Print(const std::string& name, T&& value)
{
    std::cout << name << ": " << value << "\n";
}
template <typename T, typename... Ts>
void Print(const std::string& name, T&& value, Ts&&... other)
{
    Print(name, value);
    Print(std::forward<Ts>(other)...);
}

int main()
{
    int heyo = 5;
    float whoo = 7.5;
    double eyy = 2;
    std::string s = "hello";
    MVAR(heyo, whoo, eyy, s);
}

输出：

heyo: 5
whoo: 7.5
eyy: 2
s: hello

Answer 2

不确定宏是如何工作的，但是打印所有参数都可以使用递归的可变参数模板。

#include <iostream>

template <typename T>
void myFunc(T&& value) {
    std::cout << value << '\n';
}

template <typename T, typename ...Ts>
void myFunc(T&& value, Ts&& ...rest) {
    std::cout << value << '\n';
    myFunc(std::forward<Ts>(rest)...);
}

int main() {
    myFunc(0, 1, 2);
    return 0;
}

这将允许您使用VAR宏。

Answer 3

在我看来，一种可能的方法是将递归模板解决方案（如MaLarsson所建议）与宏混合以复制参数，并在字符串中转换首次出现的变量名称。

我的意思是......如果你定义一个递归模板函数foo()（非模板地面案例只打印行尾）

void foo ()
 { std::cout << std::endl; }

template <typename A0, typename ... As>
void foo (char const * nameA0, A0 const & a0, As ... as)
 {
   std::cout << nameA0 << ' ' << a0 << ' ';

   foo(as...);
 }

和一个简单的函数宏bar()如下

#define bar(x)  #x, x

您可以使用foo()为每个参数调用bar()，如下所示

foo(bar(a), bar(b), bar(c), bar(d));

以下是一个完整的工作示例

#include <iostream>

void foo ()
 { std::cout << std::endl; }

template <typename A0, typename ... As>
void foo (char const * nameA0, A0 const & a0, As ... as)
 {
   std::cout << nameA0 << ' ' << a0 << ' ';

   foo(as...);
 }

#define bar(x)  #x, x

int main()
 {
   int a { 0 };
   std::string b { "one" };

   foo(bar(a), bar(b));
 }

Answer 4

这将帮助您实现所需的目标。我正在使用可变参数宏以及可变参数模板参数来实现此目的。此方法将帮助您打印变量的值及其名称。此方法完全与类型无关，并且支持可变数量的参数。甚至可以很好地显示STL的值，前提是您要为它们重载输出运算符

#define show(args...) describe(#args,args);
template<typename T>
void describe(string var_name,T value) //base case for template function
{
    clog<<var_name<<" = "<<value<<" ";
}

template<typename T,typename... Args>
void describe(string var_names,T value,Args... args)
{
    string::size_type pos = var_names.find(',');
    string name = var_names.substr(0,pos);
    var_names = var_names.substr(pos+1);
    clog<<name<<" = "<<value<<" | ";
    describe(var_names,args...);
}

样品使用：

int main()
{
    string a;
    int b;
    double c;
    a="string here";
    b = 7;
    c= 3.14;
    show(a,b,c);
}

输出：

a = string here | b = 7 | c = 3.14

print使用可变参数宏对调试行进行多次打印

4 个答案: