nameof

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

2,360

126

2,360

View on GitHub

Top Related Projects

rapidjson

15,111

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

flatbuffers

26,573

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

15,111

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

50,390

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

26,573

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++

A header-only C++17 library that provides nameof macros and functions for obtaining the name of a variable, type, function, macro, or enum.

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__"

// Obtains full name of variable, function, macro.
NAMEOF_FULL(somevar.some_method<int>()) -> "some_method<int>"

// Obtains raw expression text.
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 value.
NAMEOF_ENUM(color) -> "RED"
nameof::nameof_enum(color) -> "RED"

// Name of enum value known at compile time.
// This version has a lower compile-time cost and is not restricted by the enum_range limitation.
NAMEOF_ENUM_CONST(Color::GREEN) -> "GREEN"
nameof::nameof_enum<Color::GREEN>() -> "GREEN"

enum AnimalFlags { HasClaws = 1, CanFly = 2, EatsFish = 4 };

// Enum flag value to string.
auto flag = static_cast<AnimalFlags>(CanFly | EatsFish);
NAMEOF_ENUM_FLAG(flag) -> "CanFly|EatsFish"
nameof::nameof_enum_flag(flag, '$') -> "CanFly$EatsFish"

// Obtains name of enum value or default value if no name is available.
NAMEOF_ENUM_OR(Color::GREEN, "none") -> "GREEN"
NAMEOF_ENUM_OR((Color)0, "none") -> "none"
nameof::nameof_enum_or(Color::GREEN, "none") -> "GREEN"

Nameof type

Exact type spellings are compiler-specific.

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();
// Obtains type name using RTTI.
NAMEOF_TYPE_RTTI(*ptr) -> "my::detail::Derived"
NAMEOF_FULL_TYPE_RTTI(*ptr) -> "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;
const int someglobalconstvariable = 42;
// 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) -> "someglobalvariable"
nameof::nameof_pointer<global_ptr>() -> "someglobalvariable"

Integration

Single header: add nameof.hpp to your project.

CMake package:

find_package(nameof CONFIG REQUIRED)
target_link_libraries(your_target PRIVATE nameof::nameof)

vcpkg: install the nameof package with vcpkg install nameof.
Conan: add nameof/x.y.z to the requires section, where x.y.z is the required release version.
AUR: install nameof with an AUR helper, for example yay -S nameof.

CPM:

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

Compiler compatibility

nameof requires C++17 or newer and supports:

Clang/LLVM >= 5
GCC >= 9
Visual Studio >= 2017

See the reference for feature-specific requirements.

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