template-specialization

is it possible to somehow make a partial template specification a friend class? I.e. consider you have the following template class template <class T> class X{ T t; }; Now you have partial specializations, for example, for pointers template <class T> class X<T*>{ T* t; }; What I want to accomplish is that every possible X<T*> is a friend class of X<S> for ANY S . I.e. X<A*> should be a friend of X<B> . Of course, I thought about a usual template friend declaration in X: template <class T> class X{ template <class S> friend class X<S*>; } However, this does not compile, g++ tells me this: test4

Having seen this answer , I tried to come up with a variable template utility to the code from it: template <class T, template <class...> class Template> struct is_specialization : std::false_type {}; template <template <class...> class Template, class... Args> struct is_specialization<Template<Args...>, Template> : std::true_type {}; And implement it like so: template <template <class...> class Template, class... Args> constexpr bool is_specialization_v = is_specialization<Template<Args...>, Template>::value; because that's how I saw similar utilities to be implemented in the header file of

I'm trying to do some template metaprogramming and I'm finding the need to "extract" the highest index of a specialization of some structure in some type. For example, if I have some types: struct A { template<unsigned int> struct D; template<> struct D<0> { }; }; struct B { template<unsigned int> struct D; template<> struct D<0> { }; template<> struct D<1> { }; }; struct C { template<unsigned int> struct D; template<> struct D<0> { }; template<> struct D<1> { }; template<> struct D<2> { }; }; How can I then write a metafunction like this: template<class T> struct highest_index { typedef ???

I'm playing around with template specialization, and I've found an issue I can't seem to solve; this is my code: template<int length, typename T> void test(T* array) { ... test<length-1>(array); } template<typename T> void test<0>(T* array) { return; } So what I'm trying to do, is to pass the length, of what's to be processed in the template. The problem is, that the compilation of this, well outputs forever: a.cpp:83:43: error: template-id 'test<0>' in declaration of primary template a.cpp: In function 'void test(T*) [with int length= -0x000000081, T = int]': a.cpp:77:9: instantiated from

Hello I'm having problems with partial specialization. What I want to do is have a class that has a template member function that will interpret a given value to one specified by the user. For instance the class name is Value and here is a snippet of what I want to do: int *ptr1 = new int; *ptr1 = 10; Value val1 = ptr1; int *ptr2 = val1.getValue<int*>(); Value val2 = 1; int testVal = val2.getValue<int>(); Here is how I implemented such class: struct Value { Value(void *p) : val1(p){} Value(int i) : val2(i){} template<typename T> T getValue(); void *val1; int val2; }; template<typename T> T*

#include <iostream> #include <array> #include <vector> template <typename T, typename SFINAE=void> struct trait; template <typename T> struct trait<T, decltype( std::declval<const T&>().begin(), std::declval<const T&>().end(), void() )> { static const char* name() { return "Container"; } }; template <typename T, std::size_t N> struct trait<std::array<T,N>> { static const char* name() { return "std::array"; } }; int main(int argc, char* argv[]) { std::cout << trait<std::vector<int>>::name() << std::endl; std::cout << trait<std::array<int,2>>::name() << std::endl; } I was expecting the third

Many questions have been asked and they are similar to the one I am going to ask here, but they are not the same I think. I have a templated class: namespace app { template <typename T> class MyCLass { public: void dosome(); void doother(); } } /*ns*/ And implementations: template <typename T> app::MyClass<T>::dosome() {} template <typename T> app::MyClass<T>::doother() {} When I have an instance of that class to which a char is provided as template parameter, I want function dosome() to behave in a totally different way. But I just want that function to behave differently, everything else

How to specialize many template for all kinds of scalar values? (such as int , float , size_t , uint32_t , and types defined in the stdint header)? Can I avoid specializing each template for each of the types? I don't want to use boost or other non-standard libraries if possible. There are some solutions at template specialization for a set of types : Replace each template with multiple functions. One function for each scalar type. (But there are many templates. That would mean writing many functions.) Fail if the template takes a non-scalar type. (But I also want to write template for array