仅在模板类的特定特化上声明成员函数

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.