nameof c++

 _   _                             __    _____
| \ | |                           / _|  / ____|_     _
|  \| | __ _ _ __ ___   ___  ___ | |_  | |   _| |_ _| |_
| . ` |/ _` | '_ ` _ \ / _ \/ _ \|  _| | |  |_   _|_   _|
| |\  | (_| | | | | | |  __/ (_) | |   | |____|_|   |_|
|_| \_|\__,_|_| |_| |_|\___|\___/|_|    \_____|

Branch	Linux/OSX	Windows
master

C++ alternative to nameof operator in C#.

Used to obtain the simple name of a variable, type, member or function and etc. Before, you had to use string literals to refer to definitions, which is brittle when renaming code elements because tools do not know to check these string literals.

A nameof macros expression has this form:

std::cout << NAMEOF(person.address.zip_code) << std::endl; // prints "zip_code"

Features

• Simple name
• C++11
• Header-only
• Dependency-free
• Compile-time
• Compilation check

Example & Key Use Cases

• Name of a variable, member or function and etc

NAMEOF(somevar) -> "somevar"
NAMEOF(somevar.somefield) -> "somefield"
NAMEOF(SomeMethod) -> "SomeMethod"

• Name of enum

NAMEOF(SomeEnum::RED) -> "RED"
NAMEOF(SomeEnum::GREEN) -> "GREEN"

• Name of type

NAMEOF(volatile const int) -> "volatile const int int"
NAMEOF(std::string) -> "string"

• Constexpr

constexpr auto constexpr_work_fine = NAMEOF(somevar); -> "somevar"

• Compilation check

NAMEOF(std::stringgg) -> error namespace "std" has no member "stringgg"

• Validate parameters

void f(char* s) {
  if (s == nullptr)
    throw std::invalid_argument(NAMEOF(s));
}

• Serialization, for example json:

void to_json(json& j, const person& p) {
  j = json{{NAMEOF(p.name), p.name},
           {NAMEOF(p.address), p.address},
           {NAMEOF(p.age), p.age}};
}

void from_json(const json& j, person& p) {
  p.name = j.at(NAMEOF(p.name));
  p.address = j.at(NAMEOF(p.address));
  p.age = j.at(NAMEOF(p.age));
}

• Logging

void f() {
  Log(NAMEOF(f), " method entry");
}

Remarks

• The argument expression identifies a code definition, but it is never evaluated.

• If you need to get the fully-qualified name, you could use the NAMEOF_FULL().

NAMEOF_FULL(somevar.somefield) -> "somevar.somefield"
NAMEOF_FULL(&SomeStruct::SomeMethod) -> "&SomeStruct::SomeMethod"
NAMEOF_FULL(std::string) -> "std::string"

Integration

You need to add the single required file nameof.hpp, and the necessary switches to enable C++11.

Compiler compatibility

• GCC
• Clang
• MSVC

Licensed under the MIT License