How to use nameof for enum to string conversion in C++?

Use the NAMEOF_ENUM macro or nameof::nameof_enum function on an enum variable. For compile-time constants, use NAMEOF_ENUM_CONST to reduce overhead. It also supports enum flags with NAMEOF_ENUM_FLAG.

Nameof vs magic_enum for C++ reflection?

Nameof offers broader entity support (variables, types, macros) with compile-time efficiency, while magic_enum focuses specifically on enums with more features like iterating values. Choose Nameof for general name extraction and magic_enum for enum-heavy tasks.

Does nameof work with GCC and Clang?

Yes, but compatibility varies by feature. Check the reference documentation for specific compiler versions and limitations, as some advanced features might require the latest compiler support or have restrictions.

How to integrate nameof with CMake without a package manager?

Use CPM or FetchContent to include the header directly. For example, with CPM, specify the GitHub repository and tag in your CMakeLists.txt, ensuring the single header file is available during compilation.

What are the limitations of nameof with template types?

Nameof handles template types as shown with NAMEOF_TYPE_EXPR, but complex cases like dependent names or alias templates may have issues. Refer to limitations.md for details on edge cases and workarounds.

Is nameof header-only and does it slow down compilation?

Yes, it's header-only for easy integration, but this can increase compile times in large projects due to repeated processing of macros and templates. Consider precompiled headers or careful inclusion to mitigate this.

Open-Awesome

Nameof

MITC++v0.10.6

A header-only C++17 library providing macros and functions to obtain the names of variables, types, functions, macros, and enums at compile-time.

GitHub

2.3k stars127 forks0 contributors

What is Nameof?

Nameof is a header-only C++17 library that provides compile-time reflection capabilities to obtain string names of C++ entities such as variables, types, functions, macros, and enums. It solves the problem of manually hardcoding identifier names in debugging, logging, or serialization code, reducing errors and improving maintainability.

Target Audience

C++ developers working on projects that require logging, debugging, serialization, or runtime type information without heavy reflection overhead, particularly those using C++17 or later.

Value Proposition

Developers choose Nameof for its simplicity, zero runtime overhead, and ease of integration as a single-header library, offering a lightweight alternative to complex reflection systems while supporting modern C++ features.

Overview

Nameof operator for modern C++, simply obtain the name of a variable, type, function, macro, and enum

Use Cases

Best For

Adding descriptive logging with variable and function names
Serializing C++ objects with type names included
Implementing enum-to-string conversion for debugging
Creating error messages that include identifier names
Building reflection-based utilities without RTTI overhead
Generating code or documentation from C++ source structures

Not Ideal For

Projects targeting C++ standards older than C++17, as the library requires C++17 features.
Applications needing full runtime reflection for dynamic type inspection or method invocation, beyond simple name extraction.
Codebases with strict policies against macro usage, due to Nameof's heavy reliance on macros for its API.
Systems where cross-compiler support is critical without extensive testing, as compiler compatibility varies per feature (see limitations.md).

Pros & Cons

Pros

Compile-Time Zero Overhead

Most operations, like NAMEOF and NAMEOF_ENUM, are evaluated at compile-time, ensuring no runtime cost, which is ideal for performance-sensitive logging and serialization.

Wide Entity Coverage

Supports variables, member expressions, functions, macros, enums, and types with dedicated macros like NAMEOF_FULL for full names and NAMEOF_SHORT for simplified names.

Easy Package Integration

Header-only library with seamless support for vcpkg, Conan, and AUR, simplifying dependency management in various build systems.

Advanced Enum Handling

Provides enum-to-string conversion with NAMEOF_ENUM, support for enum flags via NAMEOF_ENUM_FLAG, and fallbacks for out-of-range values, reducing manual error-prone code.

Cons

Limited Reflection Scope

Only extracts string names and does not support deeper reflection like accessing member values or invoking methods, which restricts its use in complex serialization or introspection tasks.

Macro-Based Design Drawbacks

Heavy use of macros can lead to naming conflicts, obscure error messages, and challenges in debugging, contrasting with modern C++ constexpr approaches.

Compiler Dependency

Functionality is compiler-specific; the reference documentation notes varying support across compilers, requiring additional validation for cross-platform projects.

Frequently Asked Questions

Related Projects

imgui

Dear ImGui: Bloat-free Graphical User interface for C++ with minimal dependencies

A curated list of awesome C++ (or C) frameworks, libraries, resources, and shiny things. Inspired by awesome-... stuff.

Stars72,398

Forks8,320

Last commit5 days ago

ProtoBuf

Protocol Buffers - Google's data interchange format

Stars71,621

Forks16,200

Last commit15 hours ago

JSON for Modern C++

Stars50,198

Forks7,437