Class template specialization that changes only one member function

Question

I have a class template Function that takes a unsigned integer as a template argument, for the number of inputs. This template overloads operator() so the Function can be evaluated for a set of given inputs.

Usually, one of the prototypes for this member would be operator()(double, ...). However, if the template argument is 0, then that prototype wouldn't work, as it requires at least one argument.

template <unsigned Arity>
struct Function {
    void operator () (double, ...);
};

Normally, I'd just write a template specialization, but there would be a lot of redundant code since there are a lot of other member functions. Again, normally, I'd make a base class containing the redundant code for the main class definition and the specialization to inherit from.

struct FunctionBase {
    // Common code
    Function operator + (Function const &) const; // ?
};

template <unsigned Arity>
struct Function : FunctionBase { /* etc */ };

Unfortunately, I'm unsure how to go about doing this, since for example operator+ is meant to return a Function. But how can it do this if Function is only defined later on? Function inherits from the base class, and by this design operator+ is in the base class...

It could return an instance of the base class, but then we need a way to convert that instance to an instance of Function, and I know of no way to do this without copying the first instance's data, which is very expensive in terms of performance.

How can I accomplish this?

Answer 1

The question is quite difficult to answer for it's far from being clear.
Below two possibile alternatives that try to address your issues:

• If you want to go ahead with Arity template parameter, you can use sfinae'd operators to deal with Arity equal to 0:

  #include<iostream>
  
  template<int Arity>
  struct Function {
      template<int N = Arity>
      std::enable_if_t<N == 0> operator()() {
          std::cout << "arity == 0" << std::endl;
      }
  
      template<int N = Arity>
      std::enable_if_t<N != 0> operator()(double, ...) {
          std::cout << "arity != 0" << std::endl;
      }
  };
  
  int main() {
      Function<0> f1;
      Function<2> f2;
  
      f1();
      f2(0., 42);
  }
  

  This way you no longer need to introduce a base class and all the related problems don't apply anymore.

• If you mind changing approach instead, you can switch to the following pattern for your function object:

  template<typename>
  struct Function;
  
  template<typename R, typename... A>
  struct Function<R(A...)> {
      R operator()(A... args) {
          // ...
      }
  
      // ...
  };
  

  You can use it as it follows:

  Function<void(int, char)> f;
  

  If you want to have a fixed double as you first parameter for operator(), you can do this:

  template<typename R, typename... A>
  struct Function<R(double, A...)> {
      R operator()(double d, A... args) {
          // ...
      }
  
      // ...
  };
  

  And use it as it follows:

  Function<void(double, int, char)> f1;
  Function<void(double)> f1;
  

  This will help at least dealing easily with empty parameter packs (note that sizeof...(A) will return you the number of submitted parameters in any case).

  It follows a minimal, working example implementation:

  #include<iostream>
  
  template<typename>
  struct Function;
  
  template<typename R, typename... A>
  struct Function<R(A...)> {
      R operator()(A... args) {
          int _[] = { 0, (std::cout << args << std::endl, 0)... };
          (void)_;
      }
  
      template<typename... O>
      Function<R(A..., O...)> operator+(Function<R(O...)>) {
          return {};
      }
  
      // ...
  };
  
  int main() {
      Function<void(int)> f1;
      Function<void(double)> f2;
  
      f1(42);
      f2(0.);
      (f1+f2)(3, .3);
  }