Skip to content

Latest commit

 

History

History
1306 lines (955 loc) · 68 KB

standard_library_map.org

File metadata and controls

1306 lines (955 loc) · 68 KB
Raw

CPP / C++ Notes - Standard Library and Language Features Map

Standard Library, STL and language features Map

Overview

This section contains links to the C++ standard library and some C functions categorized by functionality to make it easier and faster to locate C++ APIs and also for improving its discoverability.

Standard Library Documentation

Documentation

Offline Documentation

  • Archives for offline viewing (CppReference)
    • ” For convenience, several versions of the wiki suitable for offline viewing are available.”
  • https://zealdocs.org/
    • Offline documentation browser which allows viewing the documentation of many languages such as C, C++, Scala, Tcl, Clojure and so on.
  • jeaye/stdman / Offline Manpages for UNIX, Linux, OSX
    • “stdman is a tool that parses archived HTML files from cppreference and generates groff-formatted manual pages for Unix-based systems. The goal is to provide excellent formatting for easy readability. stdman has been tested on Linux and OS X.”

Standard Library Headers

C++ Standards (Source)

  • C++ is standardized as ISO/IEC 14882. Currently, there are two versions:
    • C++98 (ISO/IEC 14882:1998) 1st standard version of C++.
    • C++03 (ISO/IEC 14882:2003) minor “bug-fix” to C++98 with no change to the language. Commonly refer to as C++98/C++03 or First C++ standard.
    • C++11 (ISO/IEC 14882:2011) 2nd standard version of C++.
    • C++14 (ISO/IEC 14882:2014) 3rd standard version of C++.
    • C++17 (ISO/IEC 14882:2017) 4th standard version of C++.
    • C++20 (ISO/IEC 14882:2020) 5th standard version of C++ (Under Development)

Container Headers

  • STL (Standard Template Library) Containers, Iterators and Function objects.

C++ Standard Library Headers

C Compatibility Headers

  • Standard ANSI C libaries ported to C++ are prefixed with “c” without “.h”. For instance, “#include <math.h>” form C becomes “#include <cmath>” in C++.
  • C Libraries.
    • <cmath> - (math.h) - Standard mathematical functions such as sin, cos, sqrt and so on.
    • <cctypes> - (ctypes.h) - Checking character types (isalpha, isdigit, isalnum, isspace, isupper, islower, isblank, iscntrl, isgraph, isprint, ispunct, isxdigit) and character conversion (toupper, tolower).
    • <climits>, <cfloat>: Size and limit of integer types (INT_MAX, INT_MIN, UINT_MAX, CHAR_BIT; and SHRT_XXX for short, LONG_XXX for long, LLONG_XXX for long long, CHAR_XXX for char) and floating-point types (DBL_MIN, DBL_MAX, DBL_DIG, DBL_MIN_EXP, DBL_MAX_EXP; and FLT_XXX for float, LDBL_XXX for long double).
    • <ctime> : time, difftime, clock, gmttime, localtime, and etc.
    • <cstdio> : C’s IO operations (scanf, printf, fscanf, fprintf, fopen, fclose, etc)
    • <cassert> : C-Assertion, macro assert for checking assumptions and pre-conditions and post-conditions.
    • <cerrno>
    • <csignal> Diagnostics and error
    • <clocale> localizaton
    • <cstdbool>, <cstdint>, <cstddef>, <cstdarg>
    • <cstdbool>, <cstdint>, <cstddef>, <cstdarg>

Language Semantics and Fundamentals

C++ Documentation related to C++ standard terminology and the C++ language semantics.

Type System

Objects

  • Object - Objects, polymorphic objects, strict aliasing and alignment.

Value Categories

Generic Programming Fundamentals

  • Named Requirements [VERY IMPORTANT, MUST READ]
    • “The named requirements listed on this page are the named requirements used in the normative text of the C++ standard to define the expectations of the standard library. Some of these requirements are being formalized in C++20 using the concepts language feature. Until then, the burden is on the programmer to ensure that library templates are instantiated with template arguments that satisfy these requirements. Failure to do so may result in very complex compiler diagnostics.”
  • Constraints and concepts
    • “Class templates, function templates, and non-template functions (typically members of class templates) may be associated with a constraint, which specifies the requirements on template arguments, which can be used to select the most appropriate function overloads and template specializations. Named sets of such requirements are called concepts. Each concept is a predicate, evaluated at compile time, and becomes a part of the interface of a template where it is used as a constraint.”

Constructors

Alignment

Strict Aliasing Rule and Type Punning

Aliasing

Restrict Keyword

Operators getting type’s data representation

Size in Bytes:

  • sizeof (OPERATOR) - Size of type in bytes.

Data Alignment / Data binary layout:

  • alignof (OPERATOR) / cppreference - Get alignment for type.
  • alignof (OPERATOR) / Microsft Docs.
    • “The alignof operator returns the alignment in bytes of the specified type as a value of type size_t.”
  • alignment_of Class | Microsoft Docs
    • “Gets alignment of the specified type. This struct is implemented in terms of alignof. Use alignof directly when you simply need to query an alignment value. Use alignment_of when you need an integral constant, for example when doing tag dispatch.”
  • aligned_storage Class | Microsoft Docs
    • “Makes suitably aligned type.”
  • align (C++) | Microsoft Docs
    • “In Visual Studio 2015 and later, use the C++11 standard alignas specifier to control alignment.”
  • Data structure alignment - Wikipedia
  • Alignment | Microsoft Docs [BEST]
    • “One of the low-level features of C++ is the ability to specify the precise alignment of objects in memory to take maximum advantage of a specific hardware architecture.”
  • Padding and Alignment of Structure Members | Microsoft Docs
    • “ANSI 3.5.2.1 The padding and alignment of members of structures and whether a bit field can straddle a storage-unit boundary Structure members are stored sequentially in the order in which they are declared: the first member has the lowest memory address and the last member the highest.”
  • pack pragma | Microsoft Docs
    • “Specifies the packing alignment for structure, union, and class members.”
  • aligned_union Class | Microsoft Docs
    • “Provides a POD type large enough and suitably aligned to store a union type, and the size required.”

Struct Offset in bytes:

RTTI Runtime Type Information:

  • typeid - Used for checking types at runtime (RTTI)

Strings and text parsing

Containers / Collections

Smart Pointers and Memory Management

Header: <memory>

Non-STL, Windows-only Smart Pointers for COM - Component Object-Model

Memory access and Pointer arithmetic

Pointer Arithmetic

  • std::size_t - Integer which represents the size of a given type in bytes. Use cases: type size, number of items in a container/collection, array size, array index and so on.
  • std::uintptr_t (Header: <cstdint>) - Unsigned integer capable of storing the address of a pointer regardless of the current platform. Note: The size in bytes of types int, long, unsigned long depends on the platform, so it is not safe to store a memory address in any of those types.
  • std::intptr_t (Header: <cstdint>) - Similar to std::uintptr_t, however it is a signed integer.
  • std::ptrdiff_t (Header: <cstdint>) - Type-safe integer for pointer arithmetic, pointer offset and array index in a platform-indepedent way.

    Memory Access

FeatureNote
Pointer
void*void pointers are used for untyped memory access (generic memory)
T* (struct T;)opaque pointer or pointer to incomplete type (similar to void*, but more type-safe)
std::byte (C++17 - Only)byte-addressable memory / byte view of the memory [better, more explicit]
std::uint8_t* (unsigned)byte-addressable memory / byte view of the memory [better, more explicit]
std::int8_t* (signed)byte-addressable memory
char* (signed)byte-addressable memory
unsigned char* (unsigned)byte-addressable memory
Object Size and Array index
std::size_t (unsigned)size of object in bytes; number of elements or array index.
std::ssize_t (signed)similar to size_t, but this type is signed.
Pointer Arithmetic
std::uintptr_t (unsigned)unsigned type that can store the address held by a pointer.
std::intptr_t (signed)signed type that can store address held by a pointer.
std::ptrdiff_t (unsigned)pointer offset and pointer difference.

Reminder example for std::size_t

double dataset [5] = { 20.51, 100.51, -2.51, 90.25, 10.0};

for(size_t i = 0; i < 5; i ++){ do_something( dataset[i] ) };

Reminder example for std::uintptr_t and ptrdiff_t / Example 1

int x = 100; 
int ptr* = &x;

// [C-style cast] => The variable p stores address (numerical value)
// pointed by the pointer variable ptr. 
std::uintptr_t p = (std::uintptr_t) ptr; 
  
// [C++-style cast]
std::uintptr_t p = reinterpret_cast<std::uintptr_t>(ptr); 
std::uintptr_t p = reinterpret_cast<std::uintptr_t>(&x);

Reminder example for std::uintptr_t and ptrdiff_t / Example 2

  • Note: Unlike in C, in C++, it is possible to perform arithmetic on void* pointers. The only safe way to perform this kind of operation is to cast void* to std::uintptr_t, peform the arithmetic operating and then cast to the
// ***********************************************************//
// ---------- Use-Case Memory Mapped File --------------------// 

 // Calls mmap() on Unix-like systems
 MemoryMappedFile fmap("/path/to/file");

 // Get void* pointer which points to the file mapping. 
 void* mmap_addr = fmap.get(): 

 // Number of bytes from the beginning of the file until the 
 // PE-header 
 constexpr ptrdiff_t PE_header_offset = 0xF8; 

 // ERROR!! Possible in C, but not possible in C++. [DO NOT COMPILE!!]
 PE_HEADER* hdr = mmap_addr + PE_header_offset;

 // C-style cast (not advisable) [AVOID]
 PE_HEADER* hdr = (PE_HEADER*) ((std::uintptr_t) mmap_addr + PE_header_offset);

 // C++-style cast [better]
 PE_HEADER* hdr = reinterpret_cast<PE_HEADER*>( reinterpret_cast<std::uintptr_t>(mmap_addr) + PE_header_offset);

Reminder example for std::uintptr_t and ptrdiff_t / Example 3

// *****************************************************************//
// --- Use-Case for Embedded Systems / MMIO - Memory Mapped IO -----// 

// MMIO - Memory-Mapped IO address of ADC - Analog-To-Digial Converter
constexpr uintptr_t ADDRESS_OF_ADC = 0xFF8ABCDE; 

// C-style cast [AVOID] 
auto mmio_adc = (volatile const std::uint32_t*) ADDRESS_OF_ADC;

// C++-style cast
auto mmio_adc = reinterpret_cast<volatile const std::uint32_t*>(ADDRESS_OF_ADC_;

Fixed Size Integers

  • Header: <cstdint> - Provides several unsigned and signed integer types with fixed size independent of current platform. As the size in bytes of types int, long and char are platform-dependent, it is not possible to rely on their sizes.
  • Types: int8_t, uint8_t, int16_t, int32_t and so on.
  • Use cases:
    • Network protocols
    • Embedded systems
    • Binary serialization
    • Raw binary data

Functional Programming and Function-object utilities

Header:

Language Features:

Library Features: (Header: <functional>)

  • std::function - Polymorphic function wrapper, it works with function pointers, lambda functions and “functors” (C++ function-objects that overloads the function-call operator (R X::operator()).
  • std::bind - Function wrapper, it generates lambda functions out of ordinary functions of multiple arguments, pointer to member functions and pointer to member variables.
  • std::placeholders (Namespace) - provides the placeholders, _1, _2, _3 and etc which are useful to generate lambda functions with std::bind. To use the placeholders, add the lines:
#include <functional> 

// Open the namespace 
using namespace std::placeholders;

double myFunctioin(int x, double y, double z, std::string const& w);

int main()
{
   auto functionOfX = std::bind(&myFunction, _1, 20.5, 9.0, "CeePlusPlus");

   ... ... ... 
   return 0;
}

or

 #include <functional> 

namespace p = std::placeholders;

double myFunctioin(int x, double y, double z, std::string const& w);

int main()
{
   auto functionOfXandY = std::bind(&myFunction, p::_1, p::_2, 9.0, "CeePlusPlus");

  ... ... ... ... 
   return 0;
}

Facilities for system programming and embedded systems

Language Features

Fixed Size Integers

  • <cstdint>
    • Fixed-width integers or platform-independent intgers which the byte size is fixed. Types: int8_t, uint8_t, int16_t, int32_t and so on.

Memory Alignment

Containers without heap-allocation

List of C++ helpful facilities for heap-deprived systems and applications such as system programming and embedded systems where heap-allocation is not desired.

Buffer or memory manipulation functions

Functions for manipulating buffers (byte arrays).

Header: <cstring> for C++ and <string.h> for C

Exceptions and error handling

Language Features:

Pre-processor Macro Errno: (Note: used by legacy code)

  • errno - Global Error Code Variable
    • “errno is a preprocessor macro used for error indication. It expands to a static (until C++11) thread-local (since C++11) modifiable lvalue of type int. Several standard library functions indicate errors by writing positive integers to errno. Typically, the value of errno is set to one of the error codes, listed in <cerrno> as macro constants that begin with the letter E, followed by uppercase letters or digits. The value of errno is ​0​ at program startup, and although library functions are allowed to write positive integers to errno whether or not an error occurred, library functions never store ​0​ in errno.”
  • Errno numbers - POSIX Error Codes
    • “Each of the macros defined in <cerrno> expands to integer constant expressions with type int, each with a positive value, matching most of the POSIX error codes. The following constants are defined (the implementation may define more, as long as they begin with ‘E’ followed by digits or uppercase letters)”
  • std::error_code
    • “std::error_code is a platform-dependent error code. Each std::error_code object holds an error code originating from the operating system or some low-level interface and a pointer to an object of type std::error_category, which corresponds to the said interface. The error code values may be not unique across different error categories.”
  • std::error_category
    • “std::error_category serves as the base class for specific error category types, such as std::system_category, std::iostream_category, etc. Each specific category class defines the error_code - error_condition mapping and holds the explanatory strings for all error_conditions. The objects of error category classes are treated as singletons, passed by reference.”

Basic Exception Type:

Misc:

Exception classes derived from std::exception:

  • std::runtime_error
    • “Defines a type of object to be thrown as exception. It reports errors that are due to events beyond the scope of the program and can not be easily predicted. Exceptions of type std::runtime_error are thrown by the following standard library components: std::locale::locale and std::locale::combine.”
  • std::logic_error
    • “Defines a type of object to be thrown as exception. It reports errors that are a consequence of faulty logic within the program such as violating logical preconditions or class invariants and may be preventable.”
  • std::domain_error
    • “Defines a type of object to be thrown as exception. It may be used by the implementation to report domain errors, that is, situations where the inputs are outside of the domain on which an operation is defined. The standard library components do not throw this exception (mathematical functions report domain errors as specified in math_errhandling). Third-party libraries, however, use this. For example, boost.math throws std::domain_error if boost::math::policies::throw_on_error is enabled (the default setting).”
  • std::system_error
    • “std::system_error is the type of the exception thrown by various library functions (typically the functions that interface with the OS facilities, e.g. the constructor of std::thread) when the exception has an associated std::error_code, which may be reported.”
  • std::bad_alloc
    • “std::bad_alloc is the type of the object thrown as exceptions by the allocation functions to report failure to allocate storage.”
  • std::bad_typeid
    • “An exception of this type is thrown when a typeid operator is applied to a dereferenced null pointer value of a polymorphic type.”
  • std::bad_cast
    • “An exception of this type is thrown when a dynamic_cast to a reference type fails the run-time check (e.g. because the types are not related by inheritance), and also from std::use_facet if the requested facet does not exist in the locale.”

Concurrency

C++11 Concurrency Features ( Thread support library)

Header: <thread> - C++11 Concurrency

C++17 New Features

  • All links to C++17 Features
  • std::basic_string_view
  • std::string_view
  • std::optional - A container which allows returning a value or returning nothing. It solves the problem of expressing that a function may return nothing in a more concise and type-safe way than usual approaches such as returning a null pointer, returning an empty object (null object pattern), throwing an exception or returning a tuple with boolean and a value. A common problem of the null pointer approach is that one may forget to check whether the value returned by the pointer is null. It may cause the null-dereference undefined behavior, which is similar to the null pointer exception problem that still haunts many languages like Java, C# and Python.
    • This type is similar to OCaml’s Option, Scala’s Option and Haskell’s Maybe.
  • std::variant - Container which works in a similar way to a sum type or disjoint-union. It is basically a type-safe C-union.
    • Use cases:
      • Visitor design pattern with little boilerplate.
      • Quasi pattern matching from functional languages (std::visit)
      • Represent AST - Abstract Syntax Tree
  • std::any - Container which can store value of any type.
  • Filesystem library [OPTIONAL] - Operating-system indepedent file system access. Operations possible: list directories, list files, check file type and permissions.

C++20 New Features (Under development)

Language Features

  • Modules C++20 - (Visual C++ Compiler) [Microsoft] [BEST]
    • Brief: “C++20 introduces modules, a modern solution for componentization of C++ libraries and programs. A module is a set of source code files that are compiled independently of the translation units that import them. Modules eliminate or greatly reduce many of the problems associated with the use of header files, and also potentially reduce compilation times. …”
  • Modules (since C++20) (CppReference)
  • Aggregate initialization
  • Concepts library (C++20)
    • “The concepts library provides definitions of fundamental library concepts that can be used to perform compile-time validation of template arguments and perform function dispatch based on properties of types. These concepts provide a foundation for equational reasoning in programs.”
  • constinit specifier (since C++20)
  • consteval specifier (since C++20)
  • Constraints and concepts (since C++20)
    • “Class templates, function templates, and non-template functions (typically members of class templates) may be associated with a constraint, which specifies the requirements on template arguments, which can be used to select the most appropriate function overloads and template specializations. Named sets of such requirements are called concepts. Each concept is a predicate, evaluated at compile time, and becomes a part of the interface of a template where it is used as a constraint.”
  • Coroutines (C++20)
    • “A coroutine is a function that can suspend execution to be resumed later. Coroutines are stackless: they suspend execution by returning to the caller and the data that is required to resume execution is stored separately from the stack. This allows for sequential code that executes asynchronously (e.g. to handle non-blocking I/O without explicit callbacks), and also supports algorithms on lazy-computed infinite sequences and other uses.”

Libraries

Math and Numerical Computing

All numeric libraries:

Headers:

  • <cmath> - C++ version of the C-header <math.h>. Contains basic trasncedental functions, sin, cos, tan and so on.
  • <complex> - Complex number library.
  • <random> - High quality C++11 random generator library. Provides lots of distributions and random number engines.
  • <limits> - Provides numeric limits of all C++ numeric types. For instance, minimum value, maximum value, number of digits, precision and episilon values of a given numeric type.
  • <ratio> - Compile-time rational arithmetic library.
  • <numeric> - Numerical “algorithms” or numerical functions for processing containers. std::accumulate, std::iner_product, std::partial_sum and std::iota.

Generic Programming / Template Metaprogramming

Fundamentals

  • Named Requirements [VERY IMPORTANT, MUST READ]
    • “The named requirements listed on this page are the named requirements used in the normative text of the C++ standard to define the expectations of the standard library. Some of these requirements are being formalized in C++20 using the concepts language feature. Until then, the burden is on the programmer to ensure that library templates are instantiated with template arguments that satisfy these requirements. Failure to do so may result in very complex compiler diagnostics.”
  • Constraints and concepts
    • “Class templates, function templates, and non-template functions (typically members of class templates) may be associated with a constraint, which specifies the requirements on template arguments, which can be used to select the most appropriate function overloads and template specializations. Named sets of such requirements are called concepts. Each concept is a predicate, evaluated at compile time, and becomes a part of the interface of a template where it is used as a constraint.”

Useful Type Traits

  • std::is_standard_layout
    • “If T is a standard layout type (that is, a scalar type, a standard-layout class, or an array of such type/class, possibly cv-qualified), provides the member constant value equal to true. For any other type, value is false. A standard-layout class is a class that satisfies StandardLayoutType.”
  • std::is_trivial
    • “If T is TrivialType (that is, a scalar type, a trivially copyable class with a trivial default constructor, or array of such type/class, possibly cv-qualified), provides the member constant value equal to true. For any other type, value is false. The behavior is undefined if std::remove_all_extents_t<T> is an incomplete type and not (possibly cv-qualified) void. The behavior of a program that adds specializations for is_trivial or is_trivial_v (since C++17) is undefined.”

General

Widely used C-functions and APIs

Memory Allocation

Header: <cstdlib> for C++ and <stdlib.h> for C

  • malloc - Allocates a given number of bytes returning a non null pointer to the allocated memory when the operation is successful.
  • free - “Deallocates the space previously allocated by std::malloc, std::calloc, std::aligned_alloc (since C++17), or std::realloc.”
  • calloc - Allocates memory for an array of num objects of size size and initializes it to all bits zero.
  • realloc - “Reallocates the given area of memory. It must be previously allocated by std::malloc(), std::calloc() or std::realloc() and not yet freed with std::free(), otherwise, the results are undefined.”

String and byte-array manipulation

Header: <cstring> for C++ and <string.h> for C

Buffer or memory manipulation functions

Header: <cstring> for C++ and <string.h> for C

File

  • fopen - Open a file for reading, writing or in binary mode.
  • fclose - Close file stream
  • fscanf
  • fread
  • fprintf - Similar to printf, but prints to a file.
  • fflush - Force file stream to be written to device.

Error Handling

Selected ISOCPP (ISO C++) Papers and Reports

  • P2028R0 - What is ABI, and What Should WG21 - Titus Winter
    • http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2028r0.pdf
    • “A short refresher on what Application Binary Interface (ABI) compatibility entails, a list of known proposals that have been dropped due to ABI compatibility concerns, and a summary of the critical issue: should we make C++23 an ABI break, or should we commit to ABI stability going forward? (This paper is similar to P1863 but provides much more introductory material and concrete suggestions.)”
  • N4028 - Defining a Portable C++ ABI - Herb Sutter
    • https://isocpp.org/files/papers/n4028.pdf
    • Summary: Exlains the drawbacks of the lack of a C++ standard ABI and proposes a common ABI.
    • A C++ developer cannot compile C++ code and share the object file with other C++ developers on the same platform and know that the result will compile and link correctly. Our status quo is that two source files a.cpp and b.cpp can only be linked together if they are compiled with both: the same version of the same compiler, or another compiler with a compatibility mode; and compatible switch settings, since most C++ compilers offer incompatible switch settings where even compiling two files with the same version of the same compiler will not link successfully.”
  • P1654R1 - ABI breakage - summary of initial comments - Roger Orr
    • http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1654r1.html
    • “The Direction Group has been asked to look at ABI (Application Binary Interface) breakage. Note that this is different from, but related to, the API (Application Programming Interface). The first step was to solicit input from EWG/LEWG to try and capture the variety of issues covered by the single term “ABI breakage”. This document is an informal summary of comments, including many of those made on the two evolution reflectors.”
  • P2137R0 - Goals and priorities for C++
    • http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2137r0.html
    • “This paper describes the goals and priorities which the authors believe make C++ an especially effective programming language for our use cases. That said, our experience, use cases, and needs are clearly not those of every user. We aren’t pushing to directly build consensus on these points. Rather, this is presented as a vehicle to advertise our needs from C++ as a high-performance systems language.”
  • P1105R1 - Leaving no room for a lower-level language: A C++ Subset
  • N3996 - Static Reflection
    • https://isocpp.org/files/papers/n3996.pdf
    • “The first two sections are devoted to the introduction to reflection and reflective programming, they contain some motivational examples and some experiences with usage of a library-based reflection utility. These can be skipped if you are knowledgeable about reflection. Section 3 contains the rationale for the design decisions. The most important part is the technical specification in section 4, the impact on the standard is discussed in section 5, the issues that need to be resolved are listed in section 7, and section 6 mentions some implementation hints.”
  • N4766 - Working Draft, C++ Extensions for Reflection - David Sankel [BLOOMBERG]
  • P2126R0 - Unleashing the Power of Allocator-Aware Software Infrastructure - Pablo Halpern, John Lakos - [BLOOMBERG]
    • http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2126r0.pdf
    • “NOTE: This white paper (i.e., this is not a proposal) is intended to motivate continued investment in developing and maturing better memory allocators in the C++ Standard as well as to counter misinformation about allocators, their costs and benefits, and whether they should have a continuing role in the C++ library and language.”
  • P0670R4 - Function reflection - Matúš Chochlík, Axel Naumann, David Sankel
    • http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0670r4.html
    • “The functionality introduced here allows for reflection of calls of concrete functions. This enables, for instance, GUI generation, building a catalogue for remote procedure calls, documentation generation, and signal/slot frameworks. Like P0194, this proposal omits attributes, templates, and reification (i.e. conversion of a meta object to the base level): all warrant a separate paper. We would welcome a paper especially on static reflection of attributes, matching the interface-style of P0194 and this paper! Linkage and friends will be part of a follow-up paper to P0194; they will have a combined “effect” on P0194 and this paper.”
  • P1240R0 - Scalable Reflection in C++
  • P0707 - Metaclasses: Generative C++ - Herb Sutter