This is the mail archive of the
libstdc++@gcc.gnu.org
mailing list for the libstdc++ project.
Simplifing tuples
- From: chris <caj at cs dot york dot ac dot uk>
- To: libstdc++ at gcc dot gnu dot org
- Date: Sat, 09 Oct 2004 12:11:14 +0100
- Subject: Simplifing tuples
The boost::tuple class uses a really quite clever head, taill recursive
process to handle about half of the functions, and the definition of the
tuple classes themselves.
While this is quite cool, it also has 4 main disadvantages
1) Error messages tend to be about 10 lines long as it unrolls templates
2) Debugging unoptimised code is a bit painful as you have to work your
way through lots of template levels
3) (similarily) unoptimised performance really sucks compared to just a
simple tuple class
4) Unrolling and inlining all those templates probably causes some (but
not too much) pain.
Instead, I am currently playing with implementing tuples by just writing
out the classes (actually, generating the header from another program)
Disadvantages of this:
1) It's not as cool
2) The header will be somewhat (but not that much) bigger
3) While I'm fairly certain, I'm not yet 100% positive it will be
possible to implement everything in this manner.
The main method looks something like:
class __dummy{};
template<class T1=__dummy, ... , class TN=_dummy>
class tuple {
static const int size=N;
T1 t1;
...
TN tn;
public:
functions...
};
template<class T1,>
class tuple<T1,_dummy,...,__dummy> {
static const int size = 1;
T1 t1;
public:
functions...
};
...
I'm currently working my way through implementing this, writing a
sizeable test suite, etc. I just wondered if anyone had any positive /
negative comments on this kind of unfolding?
Chris