Skip to content

Neargye/nameof

master
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Code

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
May 27, 2023 14:15
March 30, 2023 19:10
March 30, 2023 19:10
October 19, 2019 16:20
March 30, 2023 20:19
March 30, 2023 19:10

Stand With Ukraine

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

Github releases Conan package Vcpkg package License Try online Compiler explorer

Nameof C++

Header-only C++17 library provides nameof macros and functions to simply obtain the name of a variable, type, function, macro, and enum.

Features

  • C++17
  • Header-only
  • Dependency-free
  • Compile-time
  • Name of variable
  • Name of type, variable type
  • Name of member, pointer
  • Name of function, member function
  • Name of enum, enum variable, enum-flags
  • Name of macro

Documentation

Examples

  • Nameof

    // Name of variable.
    NAMEOF(somevar) -> "somevar"
    
    // Name of member variable.
    NAMEOF(person.address.zip_code) -> "zip_code"
    
    // Name of function.
    NAMEOF(foo<int, float>()) -> "foo"
    
    // Name of member function.
    NAMEOF(somevar.some_method()) -> "some_method"
    NAMEOF(somevar.some_method<int>()) -> "some_method"
    
    // Name of macro.
    NAMEOF(__LINE__) -> "__LINE__"
    NAMEOF(NAMEOF(structvar)) -> "NAMEOF"
    
    // Obtains full name of variable, function, macro.
    NAMEOF_FULL(somevar.some_method<int>()) -> "some_method<int>"
    
    // Obtains raw name of variable, function, macro.
    NAMEOF_RAW(somevar.some_method<int>()) -> "somevar.some_method<int>()"
  • Nameof enum

    enum class Color { RED = 1, BLUE = 2, GREEN = 4 };
    
    auto color = Color::RED;
    // Name of enum variable.
    NAMEOF_ENUM(color) -> "RED"
    nameof::nameof_enum(color) -> "RED"
    
    // Static storage enum variable to string.
    // This version is much lighter on the compile times and is not restricted to the enum_range limitation.
    NAMEOF_ENUM_CONST(Color::GREEN) -> "GREEN"
    nameof::nameof_enum<Color::GREEN>() -> "GREEN"
    
    // Enum flags variable to string.
    NAMEOF_ENUM_FLAG(Color::GREEN | Color::BLUE) -> "GREEN|BLUE"
    nameof::nameof_enum_flag<Color::GREEN | Color::BLUE>() -> "GREEN|BLUE"
    
    // Obtains name of enum variable or default value if enum variable out of range.
    NAMEOF_ENUM_OR(Color::GREEN) -> "GREEN"
    NAMEOF_ENUM_OR((Color)0, "none") -> "none"
  • Nameof type

    const my::detail::SomeClass<int>& var_ref = var;
    // Name of variable type.
    NAMEOF_TYPE_EXPR(var_ref) -> "my::detail::SomeClass<int>"
    nameof::nameof_type<decltype(var_ref)>() -> "my::detail::SomeClass<int>"
    NAMEOF_FULL_TYPE_EXPR(var_ref) -> "const my::detail::SomeClass<int>&"
    nameof::nameof_full_type<decltype(var_ref)>() -> "const my::detail::SomeClass<int>&"
    NAMEOF_SHORT_TYPE_EXPR(var_ref) -> "SomeClass"
    nameof::nameof_short_type<decltype(var_ref)>() -> "SomeClass"
    
    using T = const my::detail::SomeClass<int>&;
    // Name of type.
    NAMEOF_TYPE(T) ->"my::detail::SomeClass<int>"
    nameof::nameof_type<T>() -> "my::detail::SomeClass<int>"
    NAMEOF_FULL_TYPE(T) -> "const my::detail::SomeClass<int>&"
    nameof::nameof_full_type<T>() -> "const my::detail::SomeClass<int>&"
    NAMEOF_SHORT_TYPE(T) -> "SomeClass"
    nameof::nameof_short_type<T>() -> "SomeClass"
    
    my::detail::Base* ptr = new my::detail::Derived();
    // Name of type, using rtti.
    NAMEOF_TYPE_RTTI(*ptr) -> "my::detail::Derived"
    NAMEOF_FULL_TYPE_RTTI(*ptr) -> "volatile const my::detail::Derived&"
    NAMEOF_SHORT_TYPE_RTTI(*ptr) -> "Derived"
    
    struct A {
      int this_is_the_name;
    };
    // Obtains name of member.
    NAMEOF_MEMBER(&A::this_is_the_name) -> "this_is_the_name"
    nameof::nameof_member(&A::this_is_the_name) -> "this_is_the_name"
    
    int someglobalvariable = 0;
    // Obtains name of a function, a global or class static variable.
    NAMEOF_POINTER(&someglobalconstvariable) == "someglobalconstvariable"
    nameof::nameof_pointer(&someglobalconstvariable) == "someglobalconstvariable"
    
    constexpr auto global_ptr = &someglobalvariable;
    NAMEOF_POINTER(global_ptr) == "someglobalconstvariable"
    nameof::nameof_pointer(global_ptr) == "someglobalconstvariable"

Remarks

Integration

You should add required file nameof.hpp.

If you are using vcpkg on your project for external dependencies, then you can use the nameof package.

If you are using Conan to manage your dependencies, merely add nameof/x.y.z to your conan's requires, where x.y.z is the release version you want to use.

Archlinux users can install nameof by package manager AUR, using the following command: yay -S nameof.

Alternatively, you can use something like CPM which is based on CMake's Fetch_Content module.

CPMAddPackage(
    NAME nameof
    GITHUB_REPOSITORY Neargye/nameof
    GIT_TAG x.y.z # Where `x.y.z` is the release version you want to use.
)

Compiler compatibility

Check in the reference for each features.

Licensed under the MIT License