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?
