135 lines
3.7 KiB
Markdown
135 lines
3.7 KiB
Markdown
# Nameof C++
|
|
|
|
```text
|
|
_ _ __ _____
|
|
| \ | | / _| / ____|_ _
|
|
| \| | __ _ _ __ ___ ___ ___ | |_ | | _| |_ _| |_
|
|
| . ` |/ _` | '_ ` _ \ / _ \/ _ \| _| | | |_ _|_ _|
|
|
| |\ | (_| | | | | | | __/ (_) | | | |____|_| |_|
|
|
|_| \_|\__,_|_| |_| |_|\___|\___/|_| \_____|
|
|
```
|
|
|
|
Branch | Linux/OSX | Windows | License | Codacy
|
|
-------|-----------|---------|---------|-------
|
|
master |[](https://travis-ci.org/Neargye/nameof)|[](https://ci.appveyor.com/project/Neargye/nameof/branch/master)|[](LICENSE)|[](https://www.codacy.com/app/Neargye/nameof?utm_source=github.com&utm_medium=referral&utm_content=Neargye/nameof&utm_campaign=Badge_Grade)
|
|
|
|
## What is Nameof?
|
|
|
|
Header-only C++17 library provides nameof macros and functions to obtain simple name of variable, type, function, macro, and enum.
|
|
|
|
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.
|
|
|
|
## Features
|
|
|
|
* C++17
|
|
* Simple syntax.
|
|
* Header-only
|
|
* Dependency-free
|
|
* Compile-time
|
|
|
|
## [Examples](example/example.cpp)
|
|
|
|
* Name of variable
|
|
```cpp
|
|
// Name of variable
|
|
NAMEOF(somevar) -> "somevar"
|
|
// Name of member variable
|
|
NAMEOF(person.address.zip_code) -> "zip_code"
|
|
|
|
constexpr auto cx_name = NAMEOF(somevar);
|
|
static_assert("somevar" == cx_name);
|
|
```
|
|
|
|
* Name of function
|
|
```cpp
|
|
// Name of function
|
|
NAMEOF(some_method<int, float>) -> "some_method"
|
|
NAMEOF_FULL(some_method<int, float>) -> "some_method<int, float>"
|
|
// Name of member function
|
|
NAMEOF(somevar.foo()) -> "foo"
|
|
NAMEOF_FULL(somevar.boo<int>()) -> "boo<int>"
|
|
|
|
constexpr auto cx_name = NAMEOF(somevar.foo());
|
|
static_assert("foo" == cx_name);
|
|
```
|
|
|
|
* Name of enum
|
|
```cpp
|
|
auto c = Color::RED;
|
|
// Name of enum variable
|
|
NAMEOF_ENUM(c) -> "RED"
|
|
// Name of enum variable
|
|
nameof::nameof_enum(c) -> "RED"
|
|
|
|
constexpr auto cx_name = NAMEOF_ENUM(c);
|
|
static_assert("RED" == cx_name);
|
|
|
|
constexpr auto cx_color = Color::RED;
|
|
// Name of static storage enum variable
|
|
nameof::nameof_enum<cx_color>() -> "RED"
|
|
```
|
|
|
|
* Name of type
|
|
```cpp
|
|
// Name of variable type
|
|
NAMEOF_TYPE(Color::RED) -> "Color"
|
|
// Name of type
|
|
NAMEOF_TYPE_T(int) -> "int"
|
|
// Name of variable type
|
|
nameof::nameof_type<decltype(Color::RED)>() -> "Color"
|
|
// Name of type
|
|
nameof::nameof_type<int>() -> "int"
|
|
|
|
constexpr auto cx_name = NAMEOF_TYPE(Color::RED);
|
|
static_assert("Color" == cx_name);
|
|
```
|
|
|
|
* Name of macro
|
|
```cpp
|
|
// Name of macro
|
|
NAMEOF(__LINE__) -> "__LINE__"
|
|
|
|
constexpr auto cx_name = NAMEOF(__LINE__);
|
|
static_assert("__LINE__" == cx_name);
|
|
```
|
|
|
|
## Remarks
|
|
|
|
* Nameof return std::string_view.
|
|
|
|
* The argument expression identifies code definition, but it is never evaluated.
|
|
|
|
* If you need raw fully-qualified name, use NAMEOF_RAW.
|
|
```cpp
|
|
NAMEOF_RAW(somevar.somefield) -> "somevar.somefield"
|
|
NAMEOF_RAW(&SomeStruct::SomeMethod) -> "&SomeStruct::SomeMethod"
|
|
NAMEOF_RAW(std::string) -> "std::string"
|
|
```
|
|
|
|
* NAMEOF_ENUM does not work on the GCC.
|
|
```cpp
|
|
auto c = Color::RED;
|
|
NAMEOF_ENUM(c) -> "(Color)0"
|
|
nameof::nameof_enum(c) -> "(Color)0"
|
|
|
|
NAMEOF(Color::RED) -> "RED"
|
|
```
|
|
|
|
* Spaces and Tabs ignored
|
|
```cpp
|
|
NAMEOF( somevar ) -> "somevar"
|
|
NAMEOF( somevar ) -> "somevar"
|
|
```
|
|
|
|
## Integration
|
|
|
|
You should add required file [nameof.hpp](include/nameof.hpp).
|
|
|
|
## Compiler compatibility
|
|
|
|
* Clang/LLVM >= 5
|
|
* Visual C++ >= 15.3 / Visual Studio >= 2017
|
|
* Xcode >= 9
|
|
* GCC >= 7
|
|
|
|
## Licensed under the [MIT License](LICENSE)
|