nakameguro_feature.cpp vol17 落ち穂拾い:メタ関数編

1. <meta
   name= description <meta
   name= description content = 落ち穂拾い"/> content = 落ち穂拾い"/> いなむのみたま いなむのみたま
2. Variable
   templates
   for
   traits Variable
   templates
   for
   traits
3. 要するに
   _v 要するに
   _v メタ関数の
   _t
   と同様に、::valueを書かずにすむやつ。 例: ::value
   は
   _t
   と違って
   typename
   キーワードいらないので恩恵が⼩さい けど、まああれば使いますよね。 //
   same
   as
   std::is_same<int,
   int>::value
   std::is_same_v<int,
   int>
   
4. std::is_aggregate<T> std::is_aggregate<T> 型Tがaggregateかどうかを判定するメタ関数。
   以上！ Preconditions std::remove_all_extents_t<T>が完全型であるか、
   （cv修飾された）void型であること。
5. ところで…… ところで…… aggregateって知ってる？ aggregateって知ってる？
6. aggregateの定義 aggregateの定義 型Tが集成体であるための条件は以下である： 型Tが集成体であるための条件は以下である： 1.
   ユーザー定義されたコンストラクタ、explicitなコンストラクタ、継承 コンストラクタを持たない 2.
   private∕protectedな⾮静的メンバ変数を持たない 3.
   仮想関数を持たない 4.
   仮想基本クラス、private∕protected基本クラスを持たない
7. aggregateだと aggregateだと 集成体初期化できる 集成体初期化できる struct
   Point{
   
   
   int
   x,y;
   };
   
   Point
   a
   =
   {1,
   2};
   //
   aggregate-initialization
   
8. 集成体初期化の罠 集成体初期化の罠 **ユーザー定義された（uesr-provided）**コンストラクタ、explicitなコ ンストラクタ、継承コンストラクタを持たない ...定義？ struct
   WTF{
   
   
   WTF()
   =
   delete;
   //
   定義ではない
   };
   WTF
   a
   =
   {};
   //
   well-formed
   in
   C++11/14/17
   
9. 集成体初期化の罠 集成体初期化の罠 C++20 C++20 ユーザー定義されたコンストラクタ、explicitなコンストラクタ、継承コ ンストラクタを持たない ユーザ宣⾔されたコンストラクタまたは継承されたコンストラクタを持 たない。 struct
   Point{
   
   
   WTF()
   =
   delete;
   //
   わたくし、宣⾔です
   };
   WTF
   a
   =
   {};
   //
   ill-formed
   in
   C++20
   
10. designated
    initialization designated
    initialization C++20 C++20 GNU拡張ではしれっと使えていた。 struct
    Point{
    
    
    int
    x,y,z;
    };
    //
    C++20
    feature:
    designated
    initialization
    Point
    a
    =
    {.x=1,
    .y=2,
    .z=0};
    
11. std::bool_constant std::bool_constant namespace
    std
    {
    template
    <
    bool
    B
    >
    using
    bool_constant
    =
    integral_constant<bool,
    B>;
    }
    
12. std::bool_constant std::bool_constant example example いい例が思いつかないが・・・
    クラスを場合分けで2つ書いて、std::ture_typeとstd::falseを別々に継承す るの⾯倒なので、直接条件を羅列したりするのに使えそう。 （ほんまに使うか？） template
    <
    class...
    Pred
    >
    struct
    is_hoge
    
    
    
    
    :
    std::bool_constant<(Pred::value
    &&
    ...)>
    {};
    
13. Logical
    operation Logical
    operation metafunctions metafunctions std::cunjunction
    std::disjunction
    std::negation
    
    std::cunjunction_v
    std::disjunction_v
    std::negation_v
    
14. クラス名で雰囲気を察せよ クラス名で雰囲気を察せよ
15. クラス名で雰囲気を察せよ クラス名で雰囲気を察せよ わかんない⼈絶対いる わかんない⼈絶対いる
16. conjunction=連⾔（れんげん） conjunction=連⾔（れんげん） つまり、∧
    論理積 つまり、∧
    論理積 disjunction=選⾔（せんげん） disjunction=選⾔（せんげん） つまり、∨
    論理積 つまり、∨
    論理積 negation=否定（ひてい） negation=否定（ひてい） つまり、¬
    論理否定 つまり、¬
    論理否定
17. std::conjuncion std::conjuncion B...の論理積を⾏うメタ関数。 ⼀般にはメタ述語AとB（あるいはもっとたくさん）のすべてを満たすか 判定したい場合などに使うはず。 namespace
    std{
    template
    <class...
    B>
    struct
    conjunction;
    
    template
    <class...
    B>
    inline
    constexpr
    bool
    
    
    
    
    conjunction_v
    =
    conjunction<B...>::value;
    }
    
18. std::conjuncion std::conjuncion example example いい例が思いつかないが・・・
    パラメータパックの型がすべて同じことをSFINAEしたいときとかに使え そう。 template<typename
    T,
    typename...
    P>
    std::enable_if_t<std::conjunction_v<std::is_same<T,
    P>...>>
    func(T
    head,
    P...
    tail)
    {
    
    
    
    
    //
    ...
    }
    
19. std::conjuncion std::conjuncion in
    detail in
    detail テンプレート引数が空のとき、std::true_typeを基底クラスに持つ というテンプレート引数を持つとき、 がはじ めてfalseになる型を基底クラスに持つ がtrueのとき、 を基底クラスに持つ B , ..., B 1 n bool(B : i : value) B : n−1 : value B n
20. std::conjuncion std::conjuncion in
    detail in
    detail std::conjuncion_vは普通にbool。 static_assert(
    
    
    
    
    std::conjuncion<std::integral_constant<int,
    3>,
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    std::integral_constant<int,
    4>
    
    
    
    
    
    
    
    
    
    
    
    
    >::value
    
    
    
    
    ==
    4);
    //
    OK
    
21. std::conjuncion std::conjuncion Tips Tips がはじめてfalseとなるとき であるような はそもそもvalueを持たなくて良い B : i : value j > i Bj static_assert(
    
    
    
    
    std::conjunction_v<std::false_type,
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    std::nullptr_t>
    
    
    
    
    ==
    false);
    //
    OK
    
22. std::disjuncion std::disjuncion B...の論理和を⾏うメタ関数。 ⼀般にはメタ述語AとB（あるいはもっとたくさん）のどれかを満たすか 判定したい場合などに使うはず。 namespace
    std{
    template
    <class...
    B>
    struct
    disjuncion;
    
    template
    <class...
    B>
    inline
    constexpr
    bool
    
    
    
    
    disjuncion_v
    =
    disjuncion<B...>::value;
    }
    
23. std::disjunction std::disjunction example example いい例が思いつかない、つらい・・・
    型Tのデフォルト値をなんやかんやする例。 template
    <
    class
    T
    >
    inline
    std::enable_if_t<std::disjunction_v<
    
    
    
    
    std::is_default_constructible<T>,
    
    
    
    
    std::is_aggregate<T>>,
    T>
    default_v
    =
    []{
    
    
    
    
    if
    constexpr
    (std::is_aggregate_v<T>)
    {
    return
    T{};
    }
    
    
    
    
    else
    {
    return
    T();
    }
    }();
    
24. std::disjunction std::disjunction in
    detail in
    detail テンプレート引数が空のとき、std::false_typeを基底クラスに持つ というテンプレート引数を持つとき、 がはじ めてtrueになる型を基底クラスに持つ がfalseのとき、 を基底クラスに持つ B , ..., B 1 n bool(B : i : value) B : n−1 : value B n
25. std::disjunction std::disjunction in
    detail in
    detail std::disjunction_vは普通にbool。 static_assert(
    
    
    
    
    std::disjunction<std::integral_constant<int,
    4>,
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    std::integral_constant<int,
    3>
    
    
    
    
    
    
    
    
    
    
    
    
    >::value
    ==
    4);
    //
    OK
    
26. std::disjunction std::disjunction Tips Tips がはじめてtrueとなるとき であるような はそもそもvalueを持たなくて良い B : i : value j > i Bj static_assert(
    
    
    
    
    std::disjunction_v<std::true_type,
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    std::nullptr_t>
    
    
    
    
    ==
    true);
    //
    OK
    
27. std::negation std::negation あるメタ述語Bの論理否定を⾏うメタ関数。
    std::bool_constant<!bool(B::value)>を基底クラスに持つ。
    メタ述語の否定のメタ述語を作りたいときに。 namespace
    std{
    template
    <class
    B>
    struct
    negation:
    bool_constant<!bool(B::value)>{};
    
    template
    <class
    B>
    inline
    constexpr
    bool
    
    
    
    
    negation_v
    =
    negation<B...>::value;
    }
    
28. std::negation std::negation example example std::conjunction,
    std::disjunctionのパラメータパック内でメタ述語 の否定をしたいときに使うのは想定されるよね。 メタ述語でなくいいなら!std::is_integral_v<Ts>...と書ける。 template
    <typename...
    Ts>
    std::enable_if_t<std::conjunction_v<
    
    
    
    
    
    
    
    
    std::negation<std::is_integral<Ts>>...>>
    func(Ts...
    xs)
    {
    //
    Ts...
    はすべて整数ではない型
    
    
    //
    ...
    }
    
29. Traits
    for
    SFINAE-friendly Traits
    for
    SFINAE-friendly swap swap 多次元配列のswapがnoexcept(false)になるCore
    Issueの修正のために 提案された
30. 引数が多次元配列のとき（つまりTが配列のとき）、swapがADLの候補 に上がらないのがおわかりだろうか？ template<class
    T,
    size_t
    N>
    void
    swap(T
    (&a)[N],
    T
    (&b)[N])
    
    
    noexcept(noexcept(swap(*a,
    *b)));
    
31. Traits
    for
    SFINAE-friendly
    swapの提案によて修正。 template<class
    T,
    size_t
    N>
    void
    swap(T
    (&a)[N],
    T
    (&b)[N])
    
    
    noexcept(is_nothrow_swappable_v<T>);
    
32. is_swappableの⼀族 is_swappableの⼀族 規格書のTable
    42
    —
    Type
    property
    predicatesでひときわ⻑い説明が書い てあるので印象深い。 template<
    class
    T,
    class
    U
    >
    struct
    is_swappable_with;
    
    template<
    class
    T
    >
    struct
    is_swappable;
    
    template<
    class
    T,
    class
    U
    >
    struct
    is_nothrow_swappable_with;
    
    template<
    class
    T
    >
    struct
    is_nothrow_swappable;
    
33. is_swappable_with<T,
    U> is_swappable_with<T,
    U> using
    std::swap using
    std::swapされたという条件下かつ、 されたという条件下かつ、 未評価な⽂脈で 未評価な⽂脈で swap(declval<T>(),declval<U>()) swap(declval<T>(),declval<U>())と と swap(declval<U>(),declval<T>()) swap(declval<U>(),declval<T>())が が ともにwell-formedな式となるかを判定する。 ともにwell-formedな式となるかを判定する。 Preconditions
    型TとUが、完全型であること。
    もしくは（cv修飾された）voidか、要素数不明の配列型であること。
34. §
    23.15.4.3
    Type §
    23.15.4.3
    Type properties/C++17 properties/C++17 in
    Table
    42
    —
    Type
    property
    predicates in
    Table
    42
    —
    Type
    property
    predicates Access
    checking
    is
    performed
    as
    if
    in
    a
    context
    unrelated
    to
    T
    and
    U.
    Only
    the
    validity
    of
    the
    immediate
    context
    of
    the
    swap
    expressions
    is considered.
    [
    Note:
    The
    compilation
    of
    the
    expressions
    can
    result
    in
    side
    effects
    such as
    the
    instantiation
    of
    class
    template
    specializations
    and
    function template
    specializations,
    the
    generation
    of
    implicitly-defined
    functions, and
    so
    on.
    Such
    side
    effects
    are
    not
    in
    the
    immediate
    context
    and
    can result
    in
    the
    program
    being
    ill-formed.
    —
    end
    note
    ]
35. cpprefjpより引⽤ cpprefjpより引⽤ このメタ関数はTとUについてのswap関数の直接のコンテキストの妥当 性（そのシグネチャで有効なswapがあるかどうか）のみをチェックす る。 そのため、結果がtrueとなったとしてもswap関数の呼び出しができるこ とは保証されない（その他の要因によりコンパイルエラーが発⽣する可 能性がある）。
36. 別の⾔い⽅でもう⼀度 別の⾔い⽅でもう⼀度 シグネチャだけ⾒ると呼び出し可能だけども、（実際には）TやUの使⽤ によって、なんらかのテンプレートの実体化等やら暗黙に定義されたの 特殊メンバの⽣成なんやらをもろもろ起こした結果、それがなんらかの エラーとなるかもしれない。 そのような場合でもis_swappable_withはしっかりと実体化し、valueメ ンバ変数がtrueとなるかもしれないよ。
37. is_swappable<T> is_swappable<T> Tが参照可能な型であれば、valueメンバ変数は
    std::is_swappable_with<T&,
    T&>::valueと同じ。
    それ以外であればfalse。 Preconditions
    型Tが完全型であること、
    もしくは（cv修飾された）voidか、要素数不明の配列型であること。
38. is_nothrow_swappable<T> is_nothrow_swappable<T> is_nothrow_swappable<T> is_nothrow_swappable<T> 無例外保証検査がついてお得！ 無例外保証検査がついてお得！
39. SFINAEとは SFINAEとは テンプレートの実体化に失敗しても即座にエラーとならず、他の実体化 を探しに⾏く仕様のこと。
40. SFINAE-friendlyとは SFINAE-friendlyとは テンプレートの実体化の際にハードエラーを起こさないように設計され ているという意味。
41. SFINAE-friendlyでないメタ関数 SFINAE-friendlyでないメタ関数 #include
    <utility>
    
    template<typename
    T1,
    typename
    T2>
    struct
    PlusResultT
    {
    
    
    using
    Type
    
    
    
    
    =
    decltype(std::declval<T1>()
    
    
    
    
    
    
    
    
    
    
    
    
    
    +
    std::declval<T2>());
    };
    
    template<typename
    T1,
    typename
    T2>
    using
    PlusResult
    
    
    =
    typename
    PlusResultT<T1,
    T2>::Type;
    
42. SFINAE-friendlyなメタ関数 SFINAE-friendlyなメタ関数 #include
    <utility>
    //
    primary
    template:
    template<typename,
    typename,
    
    
    
    
    
    
    
    
    
    
    typename
    =
    std::void_t<>>
    struct
    HasPlusT
    :
    std::false_type
    {};
    
    //
    partial
    specialization
    (may
    be
    SFINAE d
    away):
    template<typename
    T1,
    typename
    T2>
    struct
    HasPlusT<T1,
    T2,
    
    
    
    
    std::void_t<decltype(std::declval<T1>()
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    +
    std::declval<T2>())>>
    
    :
    std::true_type
    {};
    
43. SFINAE-friendlyなメタ関数 SFINAE-friendlyなメタ関数 #include
    <utility>
    //
    primary
    template,
    //
    used
    when
    HasPlusT
    yields
    true
    template<typename
    T1,
    typename
    T2,
    
    
    
    
    
    
    
    
    
    bool
    =
    HasPlusT<T1,
    T2>::value>
    struct
    PlusResultT
    {
    
    
    using
    Type
    =
    decltype(std::declval<T1>()
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    +
    std::declval<T2>());
    };
    
    //
    partial
    specialization,
    used
    otherwise
    template<typename
    T1,
    typename
    T2>
    struct
    PlusResultT<T1,
    T2,
    false>
    {};
    
44. SFINAE-friendlyであるために SFINAE-friendlyであるために コンテキストが正しいかのみを確認する 結果の型を取りたい場合は先にコンテキストが正しいかを確認する そして致命的なエラーが起こる場合を特殊化する必要がある
45. 参考⽂献 参考⽂献 ISO/IEC
    14882
    2017 C++
    Templates:
    The
    Complete
    Guide
    -
    Second
    Edition working
    draft
    http://eel.is/c++draft/dcl.init.aggr Adding
    [nothrow-]swappable
    traits,
    revision
    3
    http://www.open- std.org/jtc1/sc22/wg21/docs/papers/2016/p0185r1.html Stackoverlow:
    Why
    is
    swapping
    multidimensional
    arrays
    not
    noexcept?
    https://stackoverflow.com/questions/26793979/why-is-swapping- multidimensional-arrays-not-noexcept