Use one namespace or another in function of a template parameter - c++

Question

I want to use the implementation of std::pow (from cmath) in some cases, and in other cases, I want to use myspace::pow.
namespace myspace
{
template <typename T>
T pow(T val, unsigned exp)
{
if (exp == 0) return 1;
return val*pow(val,exp-1);
}
}
The different cases are determined by a template parameter.
template <typename T>
void myFunction()
{
auto val = pow(2.1,3);
/* ... */
}
If T == double, I want val to be calculated with std::pow. If T == mydouble, I want val to be calculated with myspace::pow. Now, I have a lot of lines like auto val = pow(2.1,3);, and I would like to avoid to check for the type of T for each line of code.
struct mydouble { /* ... */ };
myFunction<double>(); // uses std::pow
myFunction<mydouble>(); // uses myspace::pow
I've been breaking my head over this, but I can't find a solution. Any suggestions?

Answer 1

There are several solutions I could suggest.
Class Dispatcher (C++11)
Just implement a functor which picks the correct implementation in accordance with its templated type:
template <typename T>
struct PowerAdapter {
auto operator()(const T& arg, const T& exp) const {
return std::pow(arg, exp);
}
};
template <>
struct PowerAdapter<myspace::MyDouble> {
auto operator()(const myspace::MyDouble& arg, unsigned exp) const {
return myspace::pow(arg, exp);
}
};
And you can use it as follows:
template <typename T>
void myFunction(const T& t) {
using Pow = PowerAdapter<T>;
auto val = Pow{}(t, t);
// ...
}
Complete Code Example
Argument-Dependent Lookup (C++98)
If your class MyDouble is in the same namespace of your pow then you can just use this C++ rule:
[...] function names are looked up in the namespaces of their arguments in addition to the scopes and namespaces considered by the usual unqualified name lookup.
So the code:
template <typename T>
void myFunction(const T& t) {
pow(t, 12);
}
will select the proper pow in accordance with the namespace of T.
Note that, in case of double, you want to select the pow from math.h in the global namespace (unqualified name lookup).
Complete Code Example
I personally don't like this approach because it hides the selection mechanism and it's more difficult to extend.
if constexpr (C++17)
You can pick a proper branch at compile time.
Wrap your select logic into a proper function (or functor). Something like:
template <typename T, typename U>
auto PowerAdapter(const T& val, const U& exp) {
if constexpr (std::is_same_v<T, myspace::MyDouble>) {
return myspace::pow(val, exp);
} else {
return std::pow(val, exp);
}
}
Complete Code Example

Answer 2

Using Argument-dependent lookup you can achieve this easily
namespace ns
{
template <typename T>
auto pow(T val, unsigned exp)
{
using std::pow;
std::cout << __FUNCTION__ << '\n';
return pow(val, exp);
}
}
struct mydouble
{
double d;
};
mydouble pow(mydouble val, unsigned exp)
{
std::cout << __FUNCTION__ << '\n';
return val;
}
int main()
{
ns::pow(mydouble{ 3.14 }, 2); // runs pow
ns::pow(4, 2); // runs std::pow
}