function-templates

Considering class templates, it is possible to provide template specializations for certain types of groups using type traits and dummy enabler template parameters. I've already asked that earlier . Now, I need the same thing for function templates: I.e., I have a template function and want a specialization for a group of types, for example, all types that are a subtype of a class X . I can express this with type traits like this: std::enable_if<std::is_base_of<X, T>::value>::type I thought about doing it this way: template <typename T, typename ENABLE = void> void foo(){ //Do something }

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

Consider #include <iostream> #include <type_traits> template <class T, class ARG_T = T&> T foo(ARG_T v){ return std::is_reference<decltype(v)>::value; } int main() { int a = 1; std::cout << foo<int>(a) << '\n'; std::cout << foo<int, int&>(a) << '\n'; } I'd expect the output to be 1 in both cases. But in the first case it's 0: consistent with the default being class ARG_T = T rather than class ARG_T = T& . What am I missing? For foo<int>(a) , ARG_T is being deduced from a , and is not taken from the default template argument. Since it's a by value function parameter, and a is an expression of

I'm trying to find out whether partial specification of templated functions is part of the C++ standard, or whether this is something compiler specific. By partial specification, I mean specifying only the types the compiler can't deduce. So if I have a template function 'f' that takes 3 types, and one is used in a parameter and can be deduced, I might call 'f' with the form f<type, type>(parameter) Here's an example: #include <iostream> #include <tuple> #include <string> template<class A, class B, class C> std::tuple<A, B> test(C c) { // do something based on c, return tuple with types A and

This is an interview question, which has been done. Which line has error ? #include<iostream> template<class T> void foo(T op1, T op2) { std::cout << "op1=" << op1 << std::endl; std::cout << "op2=" << op2 << std::endl; } template<class T> struct sum { static void foo(T op1, T op2) { std::cout << "sum=" << op2 << std::endl ; } }; int main() { foo(1,3); // line1 foo(1,3.2); // line2 foo<int>(1,3); // line3 foo<int>(1, '3') ; // line 4 sum::foo(1,2) ; // line 5 , return 0; } Line 2 has error because the template parameter is not matching the definition. Line 5 has error because the template