nameof

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

2,039

109

2,039

View on GitHub

Top Related Projects

rapidjson

14,146

A fast JSON parser/generator for C++ with both SAX/DOM style API

flatbuffers

23,057

FlatBuffers: Memory Efficient Serialization Library

Quick Overview

The Neargye/nameof project is a C++17 header-only library that provides a nameof operator, which allows you to obtain the name of a variable, type, or function as a string at compile-time. This can be useful for logging, serialization, and other scenarios where you need to work with the names of program elements.

Pros

Compile-time Evaluation: The nameof operator is evaluated at compile-time, which means it doesn't incur any runtime overhead.
Cross-platform Compatibility: The library is designed to work across various compilers and platforms, including GCC, Clang, and MSVC.
Easy to Use: The library provides a simple and intuitive API, making it easy to integrate into your C++ projects.
Header-only: The library is header-only, which means you can easily include it in your project without the need for additional build steps.

Cons

Compiler Support: The nameof operator is a C++17 feature, so it may not be available on older compilers or platforms that don't support C++17.
Limited Functionality: The library only provides the nameof operator and doesn't include additional features or utilities.
Potential Compiler Bugs: As with any library that relies on compiler-specific features, there may be occasional issues or bugs related to specific compiler versions or configurations.
Dependency Management: While the library is header-only, you still need to manage the dependency in your project, which can add some complexity.

Code Examples

Here are a few examples of how to use the nameof operator provided by the Neargye/nameof library:

#include <iostream>
#include <nameof.hpp>

struct MyClass {
    int value;
};

int main() {
    int x = 42;
    std::cout << nameof(x) << " = " << x << std::endl; // Output: x = 42

    MyClass obj;
    std::cout << nameof(&MyClass::value) << " = " << &obj.value << std::endl; // Output: value = 0x7ffee1234567

    auto lambda = [](int a, int b) { return a + b; };
    std::cout << nameof(lambda) << " = " << lambda(10, 20) << std::endl; // Output: lambda = 30
    return 0;
}

In this example, we demonstrate how to use the nameof operator to obtain the names of a variable, a class member, and a lambda function.

Getting Started

To use the Neargye/nameof library in your C++ project, follow these steps:

Download or clone the repository from GitHub:

git clone https://github.com/Neargye/nameof.git

Include the header file in your C++ source file:
```
#include <nameof.hpp>
```

Use the nameof operator to obtain the name of a variable, type, or function:

int main() {
    int x = 42;
    std::cout << nameof(x) << " = " << x << std::endl; // Output: x = 42
    return 0;
}

That's it! The Neargye/nameof library is a simple and easy-to-use header-only library that can be quickly integrated into your C++ projects.

Competitor Comparisons

rapidjson

14,146

A fast JSON parser/generator for C++ with both SAX/DOM style API

Pros of Tencent/rapidjson

Highly performant and efficient JSON parser and generator
Supports a wide range of platforms and compilers
Extensive documentation and community support

Cons of Tencent/rapidjson

Larger codebase and more complex to integrate compared to Neargye/nameof
May have a steeper learning curve for developers unfamiliar with the library
Potentially more overhead for simple use cases where Neargye/nameof may be sufficient

Code Comparison

Neargye/nameof:

#define MY_VARIABLE 42
std::cout << nameof(MY_VARIABLE) << " = " << MY_VARIABLE << std::endl; // Output: MY_VARIABLE = 42

Tencent/rapidjson:

rapidjson::Document d;
d.Parse("{\"key\":42}");
int value = d["key"].GetInt();
std::cout << value << std::endl; // Output: 42

json

42,154

JSON for Modern C++

Pros of nlohmann/json

Comprehensive and feature-rich JSON library for C++, supporting a wide range of JSON operations.
Provides a simple and intuitive API for parsing, manipulating, and serializing JSON data.
Actively maintained with a large community and regular updates.

Cons of nlohmann/json

Larger in size and complexity compared to Neargye/nameof, which may be a concern for some projects.
Requires a C++11 or later compiler, which may not be available in all environments.

Code Comparison

Neargye/nameof:

#define MY_VARIABLE 42
std::cout << nameof(MY_VARIABLE) << " = " << MY_VARIABLE << std::endl; // Output: MY_VARIABLE = 42

nlohmann/json:

nlohmann::json j = {
    {"key1", "value1"},
    {"key2", 42},
    {"key3", true}
};
std::cout << j << std::endl; // Output: {"key1":"value1","key2":42,"key3":true}

flatbuffers

23,057

FlatBuffers: Memory Efficient Serialization Library

Pros of FlatBuffers

FlatBuffers is a cross-platform, efficient, and flexible serialization library that can be used for games, servers, and mobile apps.
FlatBuffers provides a binary serialization format that is faster and more efficient than traditional serialization formats like JSON or Protocol Buffers.
FlatBuffers supports a wide range of programming languages, including C++, C#, C, Go, Java, JavaScript, PHP, Python, and Rust.

Cons of FlatBuffers

FlatBuffers has a steeper learning curve compared to Nameof, as it requires defining a schema for the data structure.
FlatBuffers may not be as suitable for small, simple projects as Nameof, which is a lightweight and easy-to-use library.
FlatBuffers may have a larger codebase and dependencies compared to Nameof, which is a single-header library.

Code Comparison

Nameof (C++):

#include <nameof.hpp>

struct Person {
    std::string name;
    int age;
};

int main() {
    std::cout << NAMEOF(Person::name) << std::endl; // Output: "name"
}

FlatBuffers (C++):

#include <flatbuffers/flatbuffers.h>

struct PersonT {
    std::string name;
    int age;
};

flatbuffers::Offset<Person> CreatePerson(flatbuffers::FlatBufferBuilder& builder, const PersonT& person) {
    auto name = builder.CreateString(person.name);
    return CreatePerson(builder, name, person.age);
}

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

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.

If you like this project, please consider donating to one of the funds that help victims of the war in Ukraine: https://u24.gov.ua.

Documentation

Features & 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

Before use, read the limitations of functionality.

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

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot