Partial specialization with more template parameters

» cpp » Partial specialization with more template parameters

By : Alexander Schulz

Date : November 23 2020, 04:01 AM

I think the issue was by ths following , Yes, a partial specialisation can indeed have more template parameters than the primary template. A typical example of this use is std::function:

code :

template <class T>
struct function;

template <class R, class... A>
struct function<R (A...)>
{
  // std::function as we know it
};

Share :

Template parameters not used in partial specialization

By : user3202527

Date : March 29 2020, 07:55 AM

This might help you You shouldn't need a specialization at all here: iterator_traits is already specialized for pointer types and if you do end up with an iterator that is a class type, you can just define those required typedefs in the iterator class.
The problem is that in order to match the primary specialization, the compiler needs to take the arguments with which the template is used, plug them into the specialization, and see whether they match.

code :

template <typename T> struct S { typedef int type; };

template <typename T> 
struct Traits { };

template <typename T> 
struct Traits<typename S<T>::type> { };

Partial template specialization of a function for a type which needs additional template parameters

By : TryAgain

Date : March 29 2020, 07:55 AM

Does that help When I have functions, I prefer to stay with functions (which is more beneficial with member functions, because you still have access to *this).

code :

template<typename T, unsigned n>
unsigned count_components_switch(boost::mpl::identity<A<T, n>>)
{
    return n;
}

template<typename T>
unsigned count_components_switch(boost::mpl::identity<T>)
{
    return 1;
}

template<typename T>
unsigned count_components()
{
    return (count_components_switch)(boost::mpl::identity<T>());
}

Partial specialization of template template parameters, with varying number of parameters

By : doosami

Date : March 29 2020, 07:55 AM

wish of those help If the title doesn't make sense, here's the gist of the problem: , In C++11 you can use variadics:

code :

template <template<typename T, typename...> class ContainerOf> 
class Foo;

c++11 -Template MetaProgramming - Error: template parameters not used in partial specialization

By : Maithili

Date : March 29 2020, 07:55 AM

hope this fix your issue Your class template BuiderType has a non type template parameter of type BuildersType and a pack of type template parameters named Args but your specialization has two non type template parameters FILENAME and CLASSNAME (where you use non of them to actually specialize BuiderType). In the line where you declare/define aBuilder you use a set of template parameters that is incompatible to the declaration of template class BuiderType; because here you do not have any non type template parameters besides the first one.
This snippet has the same behaviour:

code :

template<class ... Args> class A;

// this specialization has a template parameter that 
// 1. cannot and
// 2. will not be used in the parameter list for A
template<int I> class A<int> { };

int main()
{

  A<int> a; // error: A is an incomplete type
  A<2> b;   // error: '2' is not a type but 
            // A template expects type parameters

  return 0;
}

Define partial specialization for some external template classes with restriction for template parameters

By : fath

Date : March 29 2020, 07:55 AM

this one helps. If you're OK with using proposed but not yet standardized language features, this seems to work under gcc 6.1 with the -fconcepts flag:

code :

template <typename Base, typename Derived>
concept bool BaseOf = std::is_base_of<Base, Derived>::value;

namespace std {
  template <template<typename,std::size_t> class Tmpl, typename T, std::size_t N>
  requires BaseOf<Foo<T, N>, Tmpl<T, N>>
    class tuple_size<Tmpl<T, N>>
    : public std::integral_constant<std::size_t, N>
    { };
};

// tests
static_assert(std::tuple_size<FooDerived<int, 5>>::value == 5,
              "FooDerived");
static_assert(std::tuple_size<std::array<int, 5>>::value == 5,
              "std::array");

template <typename T>
concept bool SizedTuple = requires {
  { std::tuple_size<T>::value } -> std::size_t
};
static_assert(!SizedTuple<BarDerived<int, 5>>, "BarDerived");