Today,
I wrote some code that needed to add elements to different container variables depending on the type of a template parameter.
I solved it by writing a friend helper class specialized on its own template parameter which had a member variable of the original class. It saved
me a few hundred lines of repeating
myself without adding much complexity. However, it seemed kludgey.
I would like to know if there is a better, more elegant way.
The code below is a greatly simplified example illustrating the problem
and my solution. It compiles in g++.
#include <vector>
#include <algorithm>
#include <iostream>
namespace myNS{
template<class Elt>
struct Container{
std::vector<Elt> contents;
template<class Iter>
void set(Iter begin, Iter end){
contents.erase(contents.begin(), contents.end());
std::copy(begin, end, back_inserter(contents));
}
};
struct User;
namespace WkNS{
template<class Elt>
struct Worker{
User& u;
Worker(User& u):u(u){}
template<class Iter>
void set(Iter begin, Iter end);
};
};
struct F{ int x; explicit F(int x):x(x){} };
struct G{ double x; explicit G(double x):x(x){} };
struct User{
Container<F> a;
Container<G> b;
template<class Elt>
void doIt(Elt x, Elt y){
std::vector<Elt> v; v.push_back(x); v.push_back(y);
Worker<Elt>(*this).set(v.begin(), v.end());
}
};
namespace WkNS{
template<class Elt> template<class Iter>
void Worker<Elt>::set(Iter begin, Iter end){
std::cout << "Set a." << std::endl;
u.a.set(begin, end);
}
template<> template<class Iter>
void Worker<G>::set(Iter begin, Iter end){
std::cout << "Set b." << std::endl;
u.b.set(begin, end);
}
};
};
int main(){
using myNS::F; using myNS::G;
myNS::User u;
u.doIt(F(1),F(2));
u.doIt(G(3),G(4));
}
User is the class
I was writing.
Worker is my helper class.
I have it in its own namespace because
I don't want it causing trouble outside myNS.
Container is a container class whose definition
I don't want to modify, but is used by User in its instance variables.
doIt<F> should modify a. doIt<G> should modify b.
F
and G are open to limited modification if that would produce a more elegant solution. (As an example of one such modification, in the real application F's constructor takes a dummy parameter to make it look like G's constructor
and save
me from repeating
myself.)
In the real code, Worker is a friend of User
and member variables are private. To make the example simpler to write,
I made everything public. However, a solution that requires things to be public really doesn't answer my question.
Given all these caveats, is there a better way to write User::doIt?
