Declare member function only on specific specialization of templated class - c++

Question

I have a templated class to aid in compile time computation of physical quantities. It uses the extra template parameters (std::ratio) to ensure things like a Length can only be added to a Length, or that Area is a Length times a Length.
#include <ratio>
template <
typename Length = std::ratio<0>, // Meter
typename Mass = std::ratio<0>, // Kilogram
typename Time = std::ratio<0>, // Second
typename Current = std::ratio<0>, // Ampere
typename Temperature = std::ratio<0>, // Kelvin
typename Amount = std::ratio<0>, // Mole
typename Luminous = std::ratio<0> // Candela
>
class Quantity {
private:
double value;
public:
constexpr Quantity(double val) : value(val) {}
Quantity &operator+=(Quantity const &that) {
value += that.value;
return *this;
}
// ...
};
But sometimes I want to convert back to a simple double, for interfacing with other stuff.
I could add a member function for the templated class that returns the internal double - or enables implicit (or explicit) conversion to double when a double is needed.
constexpr double getValue() { return value; }
constexpr operator double() { return value; }
However, I really only want this implicit conversion to happen when the "dimensions" of the quantity are all 0 (all template parameters are 0).
I could just declare the same member functions and only define the specialization that I want. But that still declares that the conversion exists for types that I don't ever want to allow conversion from (you should divide by your desired units first). This makes my editor tell me it's ok but it won't link at compiletime.
Is there a way to declare member functions only on certain specializations?
Of note, I'm stuck on C++14 for now, otherwise I think an if constexpr could work...

Answer 1

No, if constexpr cannot be used to provide for conditional definition of class methods. if constexpr belongs in some method or a function, so that needs to be declared before anything can be done with if constexpr, and your goal is to not even declare it in the first place.
There is no way to directly instantiate a class method only for certain specializations or template instances, however there's a common approach that comes pretty close: simulate an overload resolution failure.
Here's a simplified example:
#include <type_traits>
#include <iostream>
template<typename T>
struct life {
template<typename=
typename std::enable_if<std::is_same<T,int>::value>::type>
constexpr int answer()
{
return 42;
}
};
int main()
{
life<int> of_brian;
std::cout << of_brian.answer() << std::endl; // Shows 42
life<double> of_black_night;
std::cout << of_black_night.answer() << std::endl; // Error
return 0;
}
The template class effectively implements answer() only for its int instance. gcc's error message, for attempting to invoke it from an undesirable instance of the template is:
error: no matching function for call to ‘life<double>::answer()’
which is a pretty close facsimile for "this doesn't exist, pal".
This is logically equivalent to what you're attempting to do with your template, the only difference is that you need to check a bunch of template parameters, instead of just one.