REFLECTIVE METAPROGRAMMING IN C++ Дэвид Вандевурд Edison Design Group

Transcription

1 REFLECTIVE METAPROGRAMMING IN C++ Дэвид Вандевурд Edison Design Group

2 REFLECTIVE METAPROGRAMMING IN C++ Daveed Vandevoorde Edison Design Group

3 WHAT IS REFLECTIVE METAPROGRAMMING?

4 REFLECTION

5 REFLECTION CODE struct S { int f(); }; int S::f(int x) { return x; } using Magic = S; DATA S: type kind: struct members: function: f type: int (int) defined: true Magic: alias type: S

6 METAPROGRAMMING auto stream_out(stream &strm)->bool { strm << "entity: " << "type/struct" << '\n'; strm << "{\n"; strm << "member: ";

7 REFLECTIVE METAPROGRAMMING Code Generation Program Code Reflection Data

8 REFLECTIVE METAPROGRAMMING Internal vs. External Compile-time vs. Run-time

9 REFLECTIVE METAPROGRAMMING Example 1 Generate a serialization function given a type.

10 REFLECTIVE METAPROGRAMMING Example 2 Generate strings given enumerator constants.

11 REFLECTIVE METAPROGRAMMING Example 3 Create a "struct of vectors" from a struct. Give it a std::vector-like interface.

12 REFLECTIVE METAPROGRAMMING Example 4 Herb Sutter's metaclasses.

13 A TASTE OF TEMPLATE METAPROGRAMMING

14 TYPE FUNCTIONS template<typename T> struct AddPtrT { using Type = T*; }; template<typename T> using AddPtr = typename AddPtrT<T>::Type; AddPtr<AddPtr<int>> ppi; // Same as "int** ppi;" AddPtr is a template meta-function.

15 HIGHER-ORDER FUNCTIONS template<typename T, template<typename> typename F, int N> struct RepeatT { using ArgT = typename RepeatT<T, F, N-1>::Type; using Type = typename F<ArgT>::Type; }; template<typename T, template<typename> typename F> struct RepeatT<T, F, 0> { using Type = T; }; template<typename T, int N> struct AddNPtrT { using Type = typename RepeatT<T, AddPtrT, N>::Type; }; template<typename T, int N> using AddNPtr = typename AddNPtrT<T, N>::Type; AddNPtr<int, 4> ppppi; // Same as "int ****ppppi;"

16 CONTAINERS // Container of types. template<typename... Ts> struct Seq {}; template<int I, typename S> struct IdxT; // Metafunction to get I-th element from sequence S. template<int I, typename S> using Idx = typename IdxT<I, S>::Type; // Container of nontypes. template<typename T, T... Ns> struct ValSeq {}; template<int... Ns> using IdxSet = ValSeq<int, Ns...>; template<int N> using MakeIdxSeq = make_integer_seq<valseq, int, N>; // Alias for IdxSeq<0, 1,..., N-1>.

17 AN IMPLEMENTATION OF IdxT template<typename T> struct IdentT { using Type = T; }; template<typename> struct IdxTHelper; template<int... Skips> struct IdxTHelper<IdxSet<Skips...>> { template<typename T> static T f(decltype(skips, (void*)0)..., T*,...); }; template<int I, typename... T> struct IdxT<I, Seq<T...>> { using Type = typename decltype( IdxTHelper<MakeIdxSeq<I>>::f((IdentT<T>*)(0)...) )::Type; };

18 REFLECTION template<typename T> struct IsFunction { static constexpr bool value = false; static constexpr bool varargs = false; }; template<typename RT, typename PTs...> struct IsFunction<RT(PTs...)> { static constexpr bool value = true; static constexpr bool varargs = false; }; template<typename RT, typename PTs...> struct IsFunction<RT(PTs...,...)> { static constexpr bool value = true; static constexpr bool varargs = true; };

19 SFINAE (SUBSTITUTION FAILURE IS NOT AN ERROR) template<typename T, bool Cond> struct EnableIfT; template<typename T> struct EnableIfT<T, true> { using Type = T; }; template<typename T, bool Cond> using EnableIf = typename EnableIfT<T, Cond>::Type; template<typename... Ts> EnableIf<void, (sizeof...(ts)%2)> pack_func(seq<ts...>); template<typename... Ts> EnableIf<void,!(sizeof...(Ts)%2)> pack_func(seq<ts...>);

20 EXPRESSION TEMPLATES template<typename T, typename Repr = Storage<T>> struct Array {... }; //... template<typename T, typename R1, typename R2> inline Array<T, XAdd<R1, R2>> operator+(array<t, R1> const &p, Array<T, R2> const &q) { return Array<T, XAdd<R1, R2>>( XAdd<R1, R2>(p.repr(), q.repr())); } //... x = 3*y+z; // Array<int, XAdd<XScale<Storage<int>>, Storage<int>>>

21 A BIT OF HISTORY

22 1988: TEMPLATES "PARAMETERIZED TYPES FOR C++" USENIX CONFERENCE

23

24

25

26 1993: BORLAND C++ 4.0

27 MARCH 1994: ERWIN UNRUH

28 1995: TODD VELDHUIZEN

29 1998: ISO C++

30

31 (THE COMPLETE GUIDE)

32 2002: SFINAE REVEALED

33 2003: ENABLE_IF Järvi, Willcock, Hinnant, and Lumsdaine

34 2011: C++11

35 2012: RELAXED CONSTEXPR

36 2013: GENERIC LAMBDAS

37 2013: RETURN DEDUCTION

38 2014: C++14

39 BOOST.HANA

40 THE 3 AXES OF REFLECTIVE METAPROGRAMMING

41 1. REFLECTION

42 2. SYNTHESIS & REIFICATION

43 3. CONTROL

44 SG7

45 P0194: STATIC REFLECTION Chochlík, Naumann, and Sankel :

46 P0194: STATIC REFLECTION New reflexpr construct: meta-types. Rich set of meta-operations. Ties naturally into template metaprogramming (also, Boost.Hana). Limited reification, but extensions considered (e.g., unreflexpr). Scheduled for TS status.

47 P0194: STATIC REFLECTION using namespace meta =...; template<typename H, typename S> requires HashAlgorithm<H> && SimpleStruct<S> void hash_append(h &h, S const &s) { meta::for_each<meta::get_data_members_t<reflexpr(s)>>( [&](auto meta_mem) { using MetaMem = typename decltype(meta_mem)::type; auto data_mem = meta::get_pointer_v<metamem>; } ); hash_append(h, s.*data_mem); }

48 P0194: STATIC REFLECTION Problems: Types as values are not intuitive. Notation is heterogeneous: <...> and (...). Poor, non-scaling compile-time.

49 P0598: REFLECT THROUGH VALUES Vandevoorde

50 P0598: REFLECT THROUGH VALUES Use a single value type for reflected metainformation. Use constexpr evaluation for control. Code looks like ordinary C++. Values are ephemeral in the compiler: Scalable. Endorsed by SG7 as the preferred direction for standard reflective metaprogramming.

51 P0598: REFLECT THROUGH VALUES Problem space/applications explored by Louis Dionne. Now basis for Herb Sutter's metaclasses. Implementation by Andrew Sutton. Sutton, Sutter

52 P0598: REFLECT THROUGH VALUES Problems: Synthesis/Reification? Constexpr extensions needed.

53 P0598: REFLECT THROUGH VALUES using namespace meta =...; template<typename H, typename S> requires HashAlgorithm<H> && SimpleStruct<S> void hash_append(h &h, S const &s) { constexpr { for (meta::info m : meta::data_members(reflexpr(s))) { } } -> { hash_append(h, s.(.m.)); } }

54 WHAT IS META::INFO? A "small" literal type, usable as a template argument. Effectively an opaque index into the AST. Could be an enum type. Ideally, wouldn't leak into run-time space. (Although harmless if an enum type.) See also P0993 by Sutton and Sutter.

55 HOW TO GET META::INFO VALUES? Using the new reflexpr operator, or by applying "immediate" functions to meta::info objects. E.g.: meta::info t1 = reflexpr(meta::info); meta::info t2 = meta::parent_of(t1); Handling meta::parent_of(reflexpr(int))? Constexpr containers/ranges of meta::info values? Functionality guided by P0194.

56 HOW TO REIFY META::INFO VALUES? Let i be a meta::info value: typename(i), namespace(i), template(i) Expression: (.i.) Template argument: (<i>) Also applicable to meta::info ranges: Produces a pack. E.g.: auto args = meta::template_args_of(i); S<(<args>)...> s;

57 SYNTHESIS? Reification + template instantiation Feasible, but limited. Perhaps extensible (new instantiation kinds). Insert strings as source Very powerful, but difficult to debug. Token stream injection Powerful and readable. Current basis of Herb Sutter's metaclasses. Controversial.

58 REIFICATION + TEMPLATE INSTANTIATION using namespace meta =...; template<typename H, typename S> requires HashAlgorithm<H> && SimpleStruct<S> void hash_append(h &h, S const &s) { constexpr { auto members = meta::data_members(reflexpr(s)); (hash_append(h, s.(.members.)),...); } } C++17 fold-expression!

59 INSERT STRINGS AS SOURCE template<typename H, typename S> requires HashAlgorithm<H> && SimpleStruct<S> void hash_append(h &h, S const &s) { constexpr { for (meta::info m : meta::data_members(reflexpr(s))) { meta::queue( meta::code( hash_append(h, s., meta::name(m), ); ), meta::full_name(m)); // Debugging aid. } } }

60 TOKEN STREAM INJECTION using namespace meta =...; template<typename H, typename S> requires HashAlgorithm<H> && SimpleStruct<S> void hash_append(h &h, S const &s) { constexpr { for (meta::info m : meta::data_members(reflexpr(s))) { } } -> { hash_append(h, s.(.m.)); } }

61 TOKEN STREAM INJECTION -> {... } -> class {... } -> namespace {... } -> namespace N {... } -> (my_metainfo) {... }

62 CONSTEXPR EXTENSIONS

63 C++20: DYNAMIC ALLOCATION Dionne, Ranns, Smith, Vandevoorde

64 THANK YOU, ANTONY POLUKHIN

65 C++20: DYNAMIC ALLOCATION constexpr int sum(int n) { int *p = new int[n]; // Dynamic allocation! int sum = 0; for (int k = 0; k<n; ++k) { p[k] = k; sum += p[k]; } delete[] p; return sum; // No dynamic allocation left. } constexpr int r = sum(13); // Okay!

66 C++20: DYNAMIC ALLOCATION #include <memory> template<typename T> using Alloc = std::allocator<t>; constexpr int sum(int n) { Alloc<int> a; int *p = a.allocate(n); int sum = 0; for (int k = 0; k<n; ++k) { std::allocator_traits<alloc>::construct(a, &p[k], k); // Okay! sum += p[k]; } a.deallocate(p); return sum; // No dynamic allocation left. } constexpr int r = sum(13); // Okay!

67 C++20: DYNAMIC ALLOCATION #include <memory> template<typename T> using Alloc = std::allocator<t>; struct Summer { [[no_unique_address]] Alloc<int> alloc; int n, *p; constexpr Summer(int n): alloc(), n(n), p(alloc.allocate(n)) { for (int k = 0; k<n; ++k) p[k] = k; } int result() const { int sum = 0; for (int k = 0; k<n; ++k) sum += p[k]; return sum; } constexpr ~Summer() { alloc.deallocate(p, n); } // constexpr destructor! }; constexpr int sum(int n) { return Summer<int>(n).result(); // No dynamic allocation left. } constexpr int r = sum(13); // Okay!

68 CONSTEXPR STANDARD CONTAINERS

69 CONSTEXPR STANDARD CONTAINERS P0784 provides the basic tools to enable some standard containers, like std::vector...

70 CONSTEXPR STANDARD CONTAINERS #include <vector> constexpr int sum(int n) { std::vector<int> v(n); int sum = 0; for (int k = 0; k<n; ++k) { v[k] = k; sum += v[k]; } return sum; } // No dynamic allocation left. constexpr int r = sum(13); // Okay!

71 CONSTEXPR STANDARD CONTAINERS #include <string> constexpr int length(char const *ntbs) { std::string s(ntbs); return (int)s.length(); } // No dynamic allocation left. constexpr int r = length("c++ Russia"); // Okay? This is a little tricky because of the "short string" optimization. Standard library writers need an additional tool...

72 CONSTEXPR EVALUATION DETECTION

73 CONSTEXPR EVALUATION DETECTION constexpr unsigned ones(unsigned word) { if (std::in_constexpr_call()) { unsigned result = 0; for (; word!= 0; word >>= 1) { if (word & 1) result += 1; } return result; } else { asm ("..."); } } unsigned two = ones(5u); // std::in_constexpr_call() == true unsigned three = ones(7u); // std::in_constexpr_call() == true unsigned fifteen = 15U; unsigned four = ones(fifteen); // std::in_constexpr_call() == false unsigned five() { return ones(0x57u); // std::in_constexpr_call() could be either }

74 CONSTEXPR EVALUATION DETECTION std::string() can use this to disable the short-string optimization during constant expression evaluations. (Thank you, LEWG.)

75 STORAGE PROMOTION

76 STORAGE PROMOTION #include <vector> constexpr std::vector<int> series(int n) { std::vector<int> v(n); for (int k = 0; k<n; ++k) { v[k] = k; } return v; } // Leftover dynamic storage!! constexpr auto vec = series(10); //?? 1. Constexpr-evaluate the destructor. 2. If successful and leftover storage is deallocated, then promote the leftover storage to the variable's storage duration, and discard the run-time destructor invocation.

77 STORAGE PROMOTION #include <vector> constexpr std::vector<int> series(int n) { std::vector<int> v(n); for (int k = 0; k<n; ++k) { v[k] = k; } return v; } // Leftover dynamic storage!! constexpr auto vec = series(10); // Okay! 1. Constexpr-evaluate the destructor. 2. If successful and leftover storage is deallocated, then promote the leftover storage to the variable's storage duration, and discard the run-time destructor invocation.

78 CONSTEXPR!

79 CONSTEXPR! constexpr! int sqr(int n) { return n*n; } constexpr int n1 = sqr(128); // Okay. int x = 1000; int n2 = sqr(x); // Error: Call does not evaluate to a // constant!

80 CONSTEXPR! constexpr! int sqr(int n) { return n*n; } constexpr! int sqrsqr(int n) { return sqr(sqr(n)); // Okay, because in "constexpr!" } // function. constexpr int sixteen = sqrsqr(2); constexpr int dblsqr(int n) { return 2*sqr(n); // Error: "sqr(n)" is not a constant. }

81 CONSTEXPR! constexpr! int ft = 42; // Never an lvalue. int f(int const &p) { return 2*p; } int r = f(ft); // ft initializes a temporary! // No direct binding.

82 2003: ACCU METACODE

83 Reflective Metaprogramming in C++ Daveed Vandevoorde Edison Design Group

84 2003: ACCU METACODE

85 Programming/C++ Templates are among the most powerful features of C++, but they remain misunderstood and underutilized, even as the C++ language and development community have advanced. In C++ Templates, Second Edition, three pioneering C++ experts show why, when, and how to use modern templates to build software that s cleaner, faster, more efficient, and easier to maintain. Now extensively updated for the C++11, C++14, and C++17 standards, this new edition presents state-of-the-art techniques for a wider spectrum of applications. The authors provide authoritative explanations of all new language features that either improve templates or interact with them, including variadic templates, generic lambdas, class template argument deduction, compile-time if, inline namespaces, and user-defined literals. They also deeply delve into fundamental language concepts (like value categories) and fully cover all standard type traits. The book starts with an insightful tutorial on basic concepts and relevant language features. The remainder of the book serves as a comprehensive reference, focusing first on language details and then on coding techniques, advanced applications, and sophisticated idioms. Throughout, examples clearly illustrate abstract concepts and demonstrate best practices for exploiting all that C++ templates can do. ++ Understand exactly how templates behave, and avoid common pitfalls ++ Use templates to write more efficient, flexible, and maintainable software ++ Master today s most effective idioms and techniques The companion website, tmplbook.com, contains sample code and additional updates. David Vandevoorde, vice president of engineering at Edison Design Group, Inc., architects key features of the company s C++ compiler. A co-founder of the renowned comp.lang.c++.moderated forum, he is also active in C++ standardization. He holds a PhD and MSc in computer science from Rensselaer Polytechnic Institute, and an MEng from Brussels Free University. His technical interests include algorithm development and teaching. Nicolai M. Josuttis is an independent systems architect, technical manager, consultant, and trainer, and has been active in C++ standardization for 20 years. Sitting in the Library Working Group he especially cares for the view of the ordinary application programmer. He is well known in the C++ community for speaking and writing with authority, being the author of The C++ Standard Library A Tutorial and Reference, Second Edition (Addison-Wesley, 2012), and other books. Douglas Gregor is a senior compiler developer with a background in C++ library design. As an early contributor to Boost, he developed several libraries that became part of the C++ standard. Later, he led the implementation of the open source Clang C++ compiler as its code owner through the completion of C++11 support, and was active in the standardization of C++11. He holds a PhD in computer science from Rensselaer Polytechnic Institute. informit.com/aw informit.com/cplusplus tmplbook.com ++ Reuse source code without compromising performance or safety ++ Benefit from utilities for generic programming in the C++ Standard Library ++ Preview the upcoming concepts feature Cover illustration: Aleksander Erin/ShutterStock Text printed on recycled paper ISBN-13: ISBN-10: $79.99 U.S. $99.99 Canada GREGOR JOSUTTIS VANDEVOORDE C++ The Complete Guide Templates SECOND EDITION Covers C ++11, C ++14, and C ++17 C++ Templates The Complete Guide SECOND EDITION David VANDEVOORDE Nicolai M. JOSUTTIS Douglas GREGOR

86 THE END