c++打印当前函数输入参数的类型、名称和值

Question

我正在寻找一个允许记录函数输入参数的功能。例如:

void func(std::string& input_name, const int n){
// print current function's inputs' type, name, and value
}

，在函数被调用后，以下内容将被打印或可读为字符串，

input1:
type: std::string,
name: input_name,
value: "something",
input2:
type: int,
name: n,
value: 12,

有没有人有什么建议?

------------ 编辑

如果打印类型或名称是不可能的，对我来说也是可以的。我可以灵活地使用接近此的解决方案，例如，如果我们可以获得输入参数列表，或等。

Answer 1

打印变量的类型和值相当简单。但是变量名在运行时不存在，所以要以字符串形式获得变量名，而不需要对其进行硬编码，唯一的方法是在编译时使用宏。宏具有字符串化标记的特性。

尝试这样做(对不起，这是记忆，我不能得到一个编译器，我今天晚些时候会更新这个):

#include <iomanip>
#include <typeinfo>
#include <type_traits>
template <typename T>
std::string getTypeName()
{
// TODO: to get a more human-readable output, use
// if-constexpr, or template specialization, or one
// of the solutions from https://stackoverflow.com/q/281818/65863... 
return typeid(T).name();
} 
template<typename T>
std::string stringify(const T& param)
{
std::ostringstream oss;
if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, char*> || std::is_same_v<T, const char*>)
oss << std::quoted(param);
else
oss << param;
return oss.str();
}
template <typename T>
void doLog(int num, std::string_view name, const T& value)
{
std::cout << "input" << num << ":" << std::endl
<< "ttype: " << getTypeName<T>() << "," << std::endl
<< "tname: " << #param << "," << std::endl
<< "tvalue: " << stringify(param) << "," << std::endl;
} 
#define LOG(num, param) doLog(num, #param, param)
void func(std::string& input_name, const int n){
LOG(1, input_name)
LOG(2, n)
}

Answer 2

这是一个使用模板代替宏的开始:(实际上，typeid.name可以输出混乱的名称)

#include <iostream>
#include <string>
#include <sstream>
namespace details
{
//-------------------------------------------------------------------------
// formatters for parameters to functions
//
template<typename type_t>
std::string format(const type_t& value)
{
std::ostringstream os;
os << typeid(type_t).name() << ":";
os << value;
return os.str();
}
// output boolean as text
std::string format(const bool& value)
{
return value ? std::string("bool:true") : std::string("bool:false");
}
// add quotes to string
std::string format(const char* value)
{
std::ostringstream os;
os << "const char*:"";
os << value;
os << """;
return os.str();
}
// recursively log all parameters
template<typename arg_t, typename... args_t>
inline void log_parameters(bool comma, const arg_t& arg, args_t... args)
{
if (comma) std::cout << ", ";
std::cout << format(arg);
if constexpr (sizeof...(args_t) > 0)
{
// true is print separating comma at next call
log_parameters(true, std::forward<args_t>(args)...);
}
}
//-------------------------------------------------------------------------
template<typename... args_t>
inline void log(const char* function, args_t... args)
{
std::cout << "function call to : " << function << "(";
// if there are any arguments to log do so
if constexpr (sizeof...(args_t) > 0)
{
// false == do not print a comma on first call
log_parameters(false, std::forward<args_t>(args)...);
}
std::cout << ");n";
}
}
void my_function(const bool x, const int y, const char* str)
{
details::log(__FUNCTION__, x, y, str);
}
int main()
{
my_function(1, 42, "Hello world!");
}