partial-specialization

Consider the following metafunction for an integral pow (it is just an example) : class Meta { template<int N, typename T> static constexpr T ipow(T x) { return (N > 0) ? (x*ipow<N-1>(x)) : ((N < 0) ? (static_cast<T>(1)/ipow<N>(x)) : (1)) } }; How to write the stop condition for such a function ? Anytime you ask yourself "how to simulate partial specialization for functions", you can think "overload, and let partial ordering decide what overload is more specialized". template<int N> using int_ = std::integral_constant<int, N>; class Meta { template<int N, typename T> static constexpr T ipow(T

I have a class template nested inside another template. Partially specializing it is easy: I just declare another template< … > block inside its parent. However, I need another partial specialization that happens to specify all its local template arguments. This makes it into an explicit specialization. Explicit specializations, for whatever reason, must be at namespace scope. To declare it outside its parent class, the parent must be nominated, which requires a non-empty template argument list. This implies partial specialization. Partial specialization is what I'm doing, and it's supposed to

This question already has an answer here: What is the meaning of “… …” token? i.e. double ellipsis operator on parameter pack 2 answers While looking at this question I found myself in the cpp reference site where I noticed a strange and new to me syntax : template<class Ret, class... Args> struct is_function<Ret(Args......)volatile &&> : std::true_type {}; Yep, 6 dots ! Initially I thought this was a typo, but after checking the libstdc++ source again there it was eg at line 444 : template<typename _Res, typename... _ArgTypes> struct is_function<_Res(_ArgTypes......) volatile &&> : public

I have the following code: template<typename T, typename Allocator = std::allocator<T> > class Carray { // ... typedef T* pointer; typedef pointer iterator; // ... }; Now I'm trying to do partial specialization for iterator_traits . It seems OK to me, but g++ 4.4.5 complains: #include <iterator> namespace std { template<typename T, typename Allocator> struct iterator_traits<typename Carray<T, Allocator>::iterator> { // line 128 typedef T value_type; typedef typename Allocator::difference_type difference_type; typedef typename Allocator::reference reference; typedef typename Allocator::pointer

Suppose I want to write a generic function void f<T>() , which does one thing if T is a POD type and another thing if T is non-POD (or any other arbitrary predicate). One way to achieve this would be to use a tag-dispatch pattern like the standard library does with iterator categories: template <bool> struct podness {}; typedef podness<true> pod_tag; typedef podness<false> non_pod_tag; template <typename T> void f2(T, pod_tag) { /* POD */ } template <typename T> void f2(T, non_pod_tag) { /* non-POD */ } template <typename T> void f(T x) { // Dispatch to f2 based on tag. f2(x, podness<std::is

According to [temp.class.order] §14.5.5.2, the selection of a partial specialization of t in this example: template< typename > struct s { typedef void v, w; }; template< typename, typename = void > struct t {}; template< typename c > struct t< c, typename c::v > {}; template< typename c > struct t< s< c >, typename s< c >::w > {}; t< s< int > > q; is equivalent to the selection of an overload of f in this example: template< typename > struct s { typedef void v, w; }; template< typename, typename = void > struct t {}; template< typename c > constexpr int f( t< c, typename c::v > ) { return 1;

I have this code template<int N, bool C = true> struct A; template<int N> struct A<N, !(N % 5)> { /* ... */ }; // should work A<25> a; That is, for numbers N that are divisible by 5 , the compiler should use the partial specialization. But the compiler won't accept that partial specialization, because the Standard requires it to reject such code where a non-type argument of a partial specialization references a parameter and is not simply a parameter (like, A<N, N> would be valid). But what is the reason of doing so? Note that I can simply change my code to a more wordy example and it is valid