Convert a program that uses includes to one using templates - c++

Question

I have created an example to show the language features I am using, the real case is not as simple. The include file is included twice, once for each class. Even though the text is the same, the underlying types are different. In the real case some variables have more initialization than others depending on the class.
Working program
ex1.cpp
#include <iostream>
class one {
public:
one(int a1,int b1) : a(a1), b(b1) {}
int a,b;
#include "ex1.h"
};
class two {
public:
two(double a1,double b1) : a(a1), b(b1) {}
double a,b;
#include "ex1.h"
};
int main()
{
one c1(1,2);
two c2(3.4,5.7);
c1.f();
c2.f();
return 0;
}
ex1.h
void f()
{
std::cout << ( a + b ) << std::endl;
}
I was hoping to change this to a program that uses templates as follows, but I get a compile error.
ex2.cpp
#include <iostream>
class one {
public:
one(int a1,int b1) : a(a1), b(b1) {}
int a,b;
void f();
};
class two {
public:
two(double a1,double b1) : a(a1), b(b1) {}
double a,b;
void f();
};
template<typename X>
void X::f()
{
std::cout << ( a + b ) << std::endl;
}
int main()
{
one c1(1,2);
two c2(3.4,5.7);
c1.f();
c2.f();
return 0;
}
The error message is error: invalid use of template type parameter 'X'

Answer 1

I believe the correct way to do what you want is to use a template to handle the different types present in the class:
#include <iostream>
template<typename X>
class foo {
public:
foo(X a1, X b1) : a(a1), b(b1) {}
X a,b;
void f();
};
template<typename X>
void foo<X>::f()
{
std::cout << ( a + b ) << std::endl;
}
int main()
{
foo<int> c1(1,2);
foo<double> c2(3.4,5.7);
c1.f();
c2.f();
return 0;
}
Generally speaking you don't want to #include code directly into your class to remove code duplication, c++ gives you some better options.
You can see this run here: http://coliru.stacked-crooked.com/a/34d146d7feac8abd

Answer 2

CRTP to the rescue:
template<class D>
struct f_support {
void f() {
// does not block all errors, but catches some:
static_assert( std::is_base_of< f_support, D >::value, "CRTP failure" );
auto* dis = static_cast<D*>(this);
std::cout << ( dis->a + dis->b ) << std::endl;
}
};
then:
class one: public f_support<one> {
...
class two: public f_support<two> {
...
You could move the implementation of f_support<D> into a .cpp file, but that is a hassle.

Answer 3

I would like to thank #Yakk and #shuttle87 for their answers. I took the simplicity of shuttle87's answer and the flexibility of Yakk's answer to come up with this one. Without your help, I would still be using include files. The problem with my solution below is that it requires all classes to have the same number of arguments in their constructor.
#include <iostream>
class one {
public:
one(int a1,int b1) : a(a1), b(b1) {}
int a,b;
void g() { std::cout << "one\t"; }
};
class two {
public:
two(double a1,double b1) : a(a1), b(b1) {}
double a,b;
void g() { std::cout << "two\t"; }
};
template<class X, typename Y>
class three : public X {
public:
three(Y a, Y b) : X(a,b) {}
void f()
{
X::g();
std::cout << ( X::a + X::b ) << std::endl;
}
};
int main()
{
three<one,int> c1(1,2);
three<two,double> c2(3.4,5.7);
c1.f();
c2.f();
return 0;
}