C++ specialize template class function without duplicating code

Question

I want to write 5 different classes, each of which has many member functions which are exactly the same, except of one, which is special for each class. Can I write this avoiding code duplication?

Regards, Aleksejs

Below is a very shortened version of my code, which throws the error:

template_test.cpp:15:35: error: invalid use of incomplete type ‘class impl_prototype<cl, 1>

#include <iostream>
using namespace std;

template <int cl, int dim>
class impl_prototype {
public:
  impl_prototype() {}

  int f(int x) { return cl + 2 * g(x); }
  int g(int x) { return cl + 1 * x;}

};

template <int cl>
int impl_prototype<cl, 1>::g(int x) { return cl + 3 * x; }

int main ()
{
  impl_prototype<0, 0> test_0;
  impl_prototype<0, 1> test_1;


  cout << test_0.f(5) << " " << test_0.g(5) << std::endl;
  cout << test_1.f(5) << " " << test_1.g(5) << std::endl;


  return 0;
}

@JoachimPileborg inheritance + partial specialization of a helper is more idiomatic, there is no `virtual` in sight in the OP's code. — TemplateRex, Aug 04 '14 at 13:20
This is an exact duplicate of [this](http://stackoverflow.com/questions/21182729/specializing-single-method-in-a-big-template-class/21183551#21183551) — Manu343726, Aug 04 '14 at 14:44

TemplateRex · Answer 1 · 2014-08-04T13:34:16.167

3

Member functions of class templates can be explicitly specialized but not partially specialized.

Just make a helper function object that you can partially specialize:

#include <iostream>
using namespace std;

template<int cl, int dim>
struct g_impl
{
  int operator()(int x) { return cl + 1 * x;}    
};

template<int cl>
struct g_impl<cl, 1>
{
  int operator()(int x) { return cl + 3 * x; }    
};

and then call that helper (the tempoary function object will optimized away):

template <int cl, int dim>
class impl_prototype 
{
public:
  impl_prototype() {}

  int f(int x) { return cl + 2 * g(x); }
  int g(int x) { return g_impl<cl, dim>()(x); }
};

int main ()
{
  impl_prototype<0, 0> test_0;
  impl_prototype<0, 1> test_1;


  cout << test_0.f(5) << " " << test_0.g(5) << std::endl;
  cout << test_1.f(5) << " " << test_1.g(5) << std::endl;


  return 0;
}

Live Example

edited Aug 04 '14 at 13:34

answered Aug 04 '14 at 13:18

TemplateRex

69,038
19
164
304

As an alternative to inheritance, we may forward to the helper: `int g(int x) { return g_impl().g(x); }`. – Jarod42 Aug 04 '14 at 13:28
@Jarod42 made a function object that can be partially specialized and called from `g()`. Thanks for your comment. – TemplateRex Aug 04 '14 at 13:34
@Walter just made it a function object that is partially specialized. – TemplateRex Aug 04 '14 at 13:35
@Walter: You may give extra info to the helper class method if needed. – Jarod42 Aug 04 '14 at 13:36

score 3 · Answer 2 · answered Aug 04 '14 at 13:45

An other method is Tag dispatching, something like:

template <int cl, int dim>
class impl_prototype
{
    int g(int x, std::integral_constant<int, 1>) { return cl + 3 * x; }

    template <int I>
    int g(int x, std::integral_constant<int, I>) { return cl + 1 * x; }

public:
    int f(int x) { return cl + 2 * g(x); }
    int g(int x) { return g(x, std::integral_constant<int, dim>());}
};

Walter · Answer 3 · 2014-08-04T13:42:35.153

You have several options.

use inheritance, where you specialise the base class template and add the multitude of other identical member functions only with the derived class templates.
declare a helper class (function object) that is partially specialised and called from impl_prototype<>::g(). This is very similar to 1., but avoids inheritance (for an example, see the answer by TemplateRex);

use SFINAE to "specialise" the member function:

template<int cl, int dim>
class impl_prototype
{
  template<bool dim_equals_one> typename std::enable_if<!dim_equals_one,int>::type
  _g(const int x) const { return cl+1*x; }
  template<bool dim_equals_one> typename std::enable_if< dim_equals_one,int>::type
  _g(const int x) const { return cl+3*x; }
public:
  int f(const int x) const { return cl+2*g(x); }
  int g(const int x) const { return _g<dim==1>(x); }    
};

I often use this last approach as it avoids all the issues of inheritance (in particular in the case of non-trivial constructors) and any helper objects outside the class.

In your particular example, a much simpler possibility is

template<int cl, int dim>
class impl_prototype
{
public:
  int f(const int x) const { return cl + 2 * g(x); }
  int g(const int x) const { return cl + (dim==1? 3*x : x); }   
};

C++ specialize template class function without duplicating code

3 Answers3

Linked