Question

在C ++ 11或更高版本中是否有某种方法可以实现类似的行为：

int some_int;
std::string x=variable_name<some_int>::value; //Theoretical code 
std::cout << x;

结果应该是：

some_int

如果没有，是否有编译器特定的方法来做到这一点？我的目标是MSVS。

Answer 1

你问：

在C ++ 11或更高版本中是否有某种方法可以实现类似的行为：
int some_int;
std::string x=type_name<some_int>::value; //Theoretical code 
std::cout << x;
结果应该是：


some_int

是的，您可以使用预处理器字符串化运算符 #：

#include <iostream>

#define NAME_OF( v ) #v

using namespace std;
auto main() -> int
{
    int some_int;
     //std::string x=type_name<some_int>::value; //Theoretical code 
    auto x = NAME_OF( some_int );
    (void) some_int;
    cout << x << endl;
}

如果您要求提供不同的内容，请发布一个新问题，因为此问题现已得到解答（修改此问题会使此答案无效）。

作为现实世界用法的示例，这是将变量及其名称传递给测试函数的宏：

#define TEST( v ) test( v, #v )

如果您想要编译时检查，相关名称是变量或类型名称，那么您只需应用sizeof，例如在逗号表达式中：

#define NAME_OF( v ) (sizeof(v), #v)

有sizeof与否之间的区别在于是否保证在编译时完全可以完成，而不是生成代码也可以在运行时执行某些操作。

为避免可能的警告，您可以向void添加伪演员：

#define NAME_OF( v ) ((void) sizeof(v), #v)

为了使这个功能也适用于功能名称，您可以添加typeid：

#define NAME_OF( name ) ((void) sizeof(typeid(name)), #name)

完整示例：

#include <typeinfo>

#define NAME_OF( name ) ((void) sizeof(typeid(name)), #name)

void foo() {}

#include <iostream>
using namespace std;
auto main() -> int
{
    int some_int;
    (void) some_int;
     //std::string x=type_name<some_int>::value; //Theoretical code 
    auto v = NAME_OF( some_int );
    auto t = NAME_OF( int );
    auto f = NAME_OF( foo );
    #ifdef TEST_CHECKING
        (void) NAME_OF( not_defined );
    #endif
    cout << v << ' ' << t << ' ' << f << endl;
}

但是，检查不是100％完美，因为它仍然可以将函数调用传递给NAME_OF宏。

Answer 2

如comments所示，您需要将变量的值及其名称传递给函数。这必须在宏的帮助下完成：

#include <iostream>

template<class T>
void foo(T var, const char* varname)
{
    std::cout << varname << "=" << var << std::endl;
}

#define FOO(var) foo(var, #var)

int main()
{
    int i = 123;
    double d = 45.67;
    std::string s = "qwerty";

    FOO(i);
    FOO(d);
    FOO(s);
    return 0;
}

输出：

i=123
d=45.67
s=qwerty

Answer 3

正如其他人所指出的那样，你确实可以使用一个宏来进行字符串化＆＃34;变量名称。但是，您可以使用以下定义，而不是简单地将其定义为#define NAMEOF(variable) #variable：

#define NAMEOF(variable) ((decltype(&variable))nullptr, #variable)

如您所见，它使用逗号运算符。该表达式的左侧部分只执行从nullptr到指向variable类型的指针的（无意义）转换，其结果立即被丢弃。右边的部分只返回字符串化变量的名称。

为什么这比在宏中使用#variable更好？

感谢decltype()运算符，如果您传递某种变量而不是某些任意字符串或文字到NAMEOF宏，则整个事情都会编译。请考虑以下示例：

double value = 523231231312.0095;

cout<< NAMEOF(value) << endl;    // value

cout<< NAMEOF(value1) << endl;   // Compiler error: 'value1' was not declared in this scope

cout<< NAMEOF(42) << endl;       // Compiler error: lvalue required as unary '&' operand

因此，如果在将来的重构中修改value变量的名称，你不会忘记修改使用其名称的地方，因为编译器会尖叫你，直到你还修复了NAMEOF对此变量的每次使用。

在MinGW-W64上测试（gcc v5.2.0）

在评论中，@iammilind和@Niall提出了另外两种定义此宏的方法，它不依赖于特定于C ++ 11的decltype()运算符：< / p>

#define NAMEOF(variable) ((void*)&variable, #variable)

...或...

// Unlike other definitions, this one, suggested by @Niall,
// won't get broken even if unary & operator for variable's type
// gets overloaded in an incompatible manner.
#define NAMEOF(variable) ((void)variable, #variable)

// On the other hand, it accepts literals as parameters for NAMEOF,
// though this might be desired behaviour, depending on your requirements.
NAMEOF(42);    // 42

根据您的评论使用@Leon建议的宏，我们得到：

template<class T>
void foo(T var, const char* varname)
{
    std::cout << varname << "=" << var << std::endl;
}

#define FOO(var) foo(var, NAMEOF(var))

int someVariable = 5;

FOO(someVariable);           // someVariable = 5

FOO(nonExistingVariable);    // compiler error!

在编译时获取变量名的标准方法

3 个答案: