template-aliases

问题 Consider this example code: template <class T> using pt_type = typename T::type; template <class T> class V { using type = int; public: using pt = pt_type<V>; }; void g() { V<int>::pt a; // Does compile pt_type<V<int>> b; // Does not compile } V<int>::pt is an alias for pt_type<V<int>> . Nevertheless the fact it is defined depends on the context where it is referred. Where is it explained in the C++ standard that the substitution of the template parameter by the template argument is performed

问题 Consider the following: template <typename T, std::size_t N> struct my_array { T values[N]; }; We can provide deduction guides for my_array , something like template <typename ... Ts> my_array (Ts ...) -> my_array<std::common_type_t<Ts...>, sizeof...(Ts)>; Now, suppose that my_array<T, 2> has some very special meaning (but only meaning, the interface & implementation stay the same), so that we'd like to give it a more suitable name: template <typename T> using special = my_array<T, 2>; It

问题 I need to use type aliases via using (or any other method) in situations like this: template <class T> typename std::enable_if< /*HERE*/>::value f (...) {}; Where I wrote HERE there are long and more than one types defined inside structures, and instead of writing typename <very long templated struct dependent on T>::type I want to write a shortcut. And I encountered this in more situations like template specializations and suffix return type syntax. So Is there any way of using using (no pun

问题 Given some class template: template <typename> struct T {}; a type alias declaration that changes the meaning of the name T like this is not allowed: struct S { using T = T<void>; // ill formed no diagnostic required }; There is an explanation given here as to why this is the case, and it also suggests a fix: struct S { using T = ::T<void>; // ok }; So my question is, how about an alias template as in this case? struct S { template <typename> using T = T<void>; // ok ? }; Is this well formed?

问题 Given some class template: template <typename> struct T {}; a type alias declaration that changes the meaning of the name T like this is not allowed: struct S { using T = T<void>; // ill formed no diagnostic required }; There is an explanation given here as to why this is the case, and it also suggests a fix: struct S { using T = ::T<void>; // ok }; So my question is, how about an alias template as in this case? struct S { template <typename> using T = T<void>; // ok ? }; Is this well formed?

问题 Im currently implementing a tiny metaprogramming-based compile-time computations library. If have defined a base class for operators, wich has a result typedef (I have decided to use integral wrappers like std::integral_constant as values instead of raw integral values, to provide an uniform interface along the library), and a n-ary operator base class, that checks if the operators has at least one operand: template<typename RESULT> struct operator { using result = RESULT; }; template

问题 Im currently implementing a tiny metaprogramming-based compile-time computations library. If have defined a base class for operators, wich has a result typedef (I have decided to use integral wrappers like std::integral_constant as values instead of raw integral values, to provide an uniform interface along the library), and a n-ary operator base class, that checks if the operators has at least one operand: template<typename RESULT> struct operator { using result = RESULT; }; template

问题 Template aliases are very convenient in simplifying types like typename F <T>::type to just F <T> , where T and type are types. I would like to do the same for templates like F <T>::map , i.e., simplify them to F <T> , where T and map are template structs or aliases. For instance, consider the following definitions: template <bool B> using expr = std::integral_constant <bool, B>; template <bool B> using _not = expr <!B>; template <template <typename> class F> struct neg_f { template <typename

问题 Template aliases are very convenient in simplifying types like typename F <T>::type to just F <T> , where T and type are types. I would like to do the same for templates like F <T>::map , i.e., simplify them to F <T> , where T and map are template structs or aliases. For instance, consider the following definitions: template <bool B> using expr = std::integral_constant <bool, B>; template <bool B> using _not = expr <!B>; template <template <typename> class F> struct neg_f { template <typename

问题 The following program... #include <iostream> #include <type_traits> template <typename T> struct Template{}; template <typename T> using Alias = Template<T>; template < template <typename> class T1, template <typename> class T2 > struct is_same_template : std::false_type{}; template < template <typename> class T > struct is_same_template<T, T> : std::true_type{}; int main() { std::cout << std::boolalpha; std::cout << "Template == Template: " << is_same_template<Template, Template>::value <<