How to change template instantiate order? - c++

Question

I want to change the instantiate order of the overload templates. My code are as follow:
#include <iostream>
#include <vector>
using namespace std;
template<typename T>
struct Base
{
};
template<typename T>
struct Derived:Base<T>
{
};
//template 1
template<typename T1>
void f(Base<T1>& a){
cout<<"in 1\n";
}
//template 2
template<typename T2>
void f(T2 b){
cout<<"in 2\n";
}
int main(){
Derived<int> v1;
f(v1);
}
The compiler will chose template 2 as default, but I want it to chose template 1.

Answer 1

With custom traits
template <typename T> std::true_type derive_from_base_impl(const Base<T>*);
std::false_type derive_from_base_impl(...);
template <typename T>
using derive_from_base = decltype(derive_from_base_impl(std::declval<T*>()));
static_assert(!derive_from_base<int>::value, "");
static_assert(derive_from_base<Derived<int>>::value, "");
And SFINAE, you may do
template<typename T>
void f(Base<T>& a) { std::cout << "in 1\n"; }
template<typename T>
std::enable_if_t<!derive_from_base<T>::value>
f(T b) { std::cout << "in 2\n"; }
Demo

Answer 2

The right term for this is overload resolution preferences, and second overload is chosen because it is a better match. It appeared to be more challenging than I expected to put together a code which would make sure proper overload was selected. Here it is:
#include <type_traits>
#include <iostream>
template<typename T>
struct Base { };
template<typename T>
struct Derived:Base<T> { };
template <class T>
struct template_argument { using type = void*; };
template <template <class > class T, class ARG>
struct template_argument<T<ARG> > {
using type = ARG;
};
template <class T>
using template_argument_t = typename template_argument<T>::type;
template<typename T1>
void f(Base<T1>& ){
std::cout << "Base-expecting f called\n";
}
template<class T>
void f(T, std::enable_if_t<!std::is_base_of<Base<template_argument_t<T> >, T>::value>* = nullptr ) {
std::cout << "Generic f was called.\n";
}
template <class T>
struct Z { };
int main(){
Derived<int> v1;
f(v1);
f(int() );
f(Z<int>() );
}
Output:
Base-expecting f called
Generic f was called.
Generic f was called.

Answer 3

The answer is quite simple, all you have to do is prevent the second template to be instantiated for a certain class, which can be done quickly using std::enable_if_t from the type_traits header:
Template 2 becomes this, and Template 1 remains unchanged
//template 2
template<typename T2, std::enable_if_t<!std::is_base_of<Base<T2>, T2>::value>>
void f(T2 b) {
cout << "in 2\n";
}

Answer 4

Provide an argument that has a better match:
int main(){
Derived<int> v1;
f(v1); // in 2
f((Base<int>&)v1); // in 1
}
In this case
f(v1) will resolve to f<Base<int>>(v1)
and f((Base<int>&)v1) to f<int>(v1)