Extensions for reflection

The C++ Extensions for Reflection, ISO/IEC TS 23619:2021, specifies modifications to the core language and defines new components for the C++ standard library listed on this page.

The Reflection TS is based on the C++20 standard (except that the definition of concepts are specified in the style of Concepts TS ).

Core language changes

reflexpr-specifier

A reflexpr-specifier is of form reflexpr ( reflexpr-operand ) , and specifies a meta-object type (see below).

reflexpr-operand can be one of following:

where function-call-expression is

and functional-type-conv-expression are following sorts of expressions which perform explict cast :

The operand to the reflexpr-specifier shall be a type , namespace , enumerator , variable, data member , function parameter , captured entity , function-call-expression or functional-type-conv-expression , and parenthesized expression. reflexpr ( :: ) reflects the global namespace.

For a reflexpr-operand of form ( expression ) , the expression shall be a (possibly multi-parenthesized) function-call-expression or functional-type-conv-expression .

If an unparenthesized operand can be treated as either a type-id or a functional-type-conv-expression , then it is treated as a type-id . Parenthesizes can be used for disambiguation between function-style cast and a type-id . For example, given a class type X with default constructor, reflexpr ( X ( ) ) reflects the function type X ( ) , and reflexpr ( ( X ( ) ) ) reflects the expression X ( ) .

If the operand designates both an alias and a class name, the type represented by the reflexpr-specifier reflects the alias and satisfies reflect::Alias .

If the operand designates a name whose declaration is enclosed in a block scope and the named entity is neither captured nor a function parameter, the program is ill-formed.

Meta-object types

A meta-object type is an unnamed, incomplete namespace-scope class type. A type satisfies the concept reflect::Object if and only if it is a meta-object type. Meta-object types may satisfy other concepts, depending on the operand to reflexpr .

It is unspecified whether repeatedly applying reflexpr to the same operand yields the same type or a different type. If a meta-object type reflects an incomplete class type, certain type transformations cannot be applied.

A meta-object type allows inspection of some properties of the operand to reflexpr through type traits or type transformations on it.

Overload resolution

If the postfix-expression of the function-call-expression is of class type, i.e. e in the function-call-expression e ( args ) is of class type, then the user-defined conversion function of the type of the postfix-expression ( e ) shall not be used.

If postfix-expression is not of class type, it shall name a function that is the unique result of overload resolution.

struct Functor
{
    void operator()(int) const;
 
    using fptr_t = void(*)(std::nullptr_t);
    operator fptr_t() const;
};
 
using Meta0 = reflexpr(Functor{}(0));          // OK
// using Meta1 = reflexpr(Functor{}(nullptr)); // error: conversion function used

Reflection-related

An alias is a name introduced by a typedef declaration, an alias-declaration , or a using-declaration .

An entity or alias B is reflection-related to an entity or alias A if

1. A and B are the same entity or alias,
2. A is a variable or enumerator and B is the type of A ,
3. A is an enumeration and B is the underlying type of A ,
4. A is a class and B is a member or base class of A ,
5. A is a non-template alias that designates the entity B ,
6. A is not the global namespace and B is an enclosing class or namespace of A ,
7. A is the parenthesized expression ( B ),
8. A is a lambda capture of the closure type B ,
9. A is the closure type of the lambda capture B ,
10. B is the type specified by the functional-type-conv-expression A ,
11. B is the function selected by overload resolution for a function-call-expression A ,
12. B is the return type, a parameter type, or function type of the function A , or
13. B is reflection-related to an entity or alias X and X is reflection-related to A .

Reflection-relation relationship is reflexive and transitive, but not symmetric.

Informally speaking, the case that B is reflection-related to A means that B participates in the declaration or definition of A .

Zero or more successive applications of type transformations that yield meta-object types to the type denoted by a reflexpr-specifier enable inspection of entities and aliases that are reflection-related to the operand; such a meta-object type is said to reflect the respective reflection-related entity or alias.

struct X;
struct B
{
    using X = ::X;
    typedef X Y;
};
struct D : B
{
    using B::Y;
};
// ::X, but not B::X or B::Y is reflection-related to D::Y

Miscellaneous

• An expression used as reflexpr-operand is an unevaluated expressions and potentially constant evaluated .
• For the purpose of determination of variables captured in a lambda expression by a capture-default, a reflexpr operand is not considered to be an unevaluated operand.
• A function or variable of static storage duration reflected by meta-object type T is odr-used by the specialization std :: experimental :: reflect :: get_pointer < T > , as if by taking the address of an id-expression nominating the function or variable.
• There can be more than one definition of a meta-object type, as long as all operations on this type yield the same constant expression results.
• A type is dependent if it is denoted by a reflexpr-specifier, and the operand
  • is a type-dependent expression or a (possibly parenthesized) functional-type-conv-expression with at least one type-dependent immediate subexpression, or
  • designates a dependent type or a member of an unknown specialization or a value-dependent constant expression .

Keywords

reflexpr

Predefined feature testing macros

Library support

Concepts

Meta-object operations

Library feature testing macros

Satisfaction of concepts

The following table lists that whether a meta-object type reflecting an operand satisfies concepts introduced by the Reflection TS.

If the operand of the form id-expression is a constant expression, the type specified by the reflexpr-specifier also satisfies reflect::Constant .

If the reflexpr-operand designates a class member, the type represented by the reflexpr-specifier also satisfies reflect::RecordMember .

See also