Namespaces
Variants
Views
Actions

C++ keywords: reflexpr (reflection TS)

From cppreference.com
< cpp‎ | keyword
 
 
C++ language
General topics
Flow control
Conditional execution statements
if
Iteration statements (loops)
for
range-for (C++11)
Jump statements
Functions
Function declaration
Lambda function declaration
inline specifier
Dynamic exception specifications (until C++20)
noexcept specifier (C++11)
Exceptions
Namespaces
Types
Specifiers
decltype (C++11)
auto (C++11)
alignas (C++11)
Storage duration specifiers
Initialization
Expressions
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Implicit conversions - Explicit conversions
static_cast - dynamic_cast
const_cast - reinterpret_cast
Memory allocation
Classes
Class-specific function properties
explicit (C++11)
static
Special member functions
Templates
Miscellaneous
 
 

[edit] Usage

  1. gets the member list of a class type, or the enumerator list of an enum type.
  2. gets the name of type and member.
  3. detects whether a data member is static or constexpr.
  4. detects whether member function is virtual, public, protected or private.
  5. get the row and column of the source code when the type defines.

[edit] Example

reflexpr provides us the meta info of the object via meta-object types. Note that std::reflect::get_data_members_t make programmers able to visit any class just like std::tuple.

#include <string>
#include <vector>
 
struct S {
    int b;
    std::string s;
    std::vector<std::string> v;
};
 
// Reflection TS
#include <experimental/reflect>
using meta_S = reflexpr(S);
using mem = std::reflect::get_data_members_t<meta_S>;
using meta = std::reflect::get_data_members_t<mem>;
static_assert(std::reflect::is_public_v<meta>); // successful
 
int main() {}

We can also know the name info from reflexpr:

#include <string>
#include <string_view>
#include <iostream>
// Reflection TS
#include <experimental/reflect>
template <typename Tp>
constexpr std::string_view nameof() {
 using TpInfo = reflexpr(Tp);
 using aliased_Info = std::experimental::reflect::get_aliased_t<TpInfo>;
 return std::experimental::reflect::get_name_v<aliased_Info>;
}
 
int main(){
 std::cout << nameof<std::string>() << '\n';
 static_assert(nameof<std::string>() == "basic_string"); // successful
}

This is an example of getting the scope of a type in the Reflection TS.

namespace Foo{
 struct FooFoo{int FooFooFoo};
}
namespace Bar{
 using BarBar = ::Foo::FooFoo;
}
using BarBarInfo = reflexpr(::Bar::BarBar);
using BarBarScope = ::std::experimental::reflect::get_scope_t<BarBarInfo>; // Bar, not Foo
 
struct Spam{int SpamSpam;};
struct Grok{
 using GrokGrok = Spam::SpamSpam;
};
using GrokGrokInfo = reflexpr(::Grok::GrokGrok);
using GrokGrokScope = std::experimental::reflect::get_scope_t<GrokGrokInfo>; // Grok, not Spam