Re: Templates HowTo?
keith@bytebrothers.co.uk wrote in news:302ac42c-9f52-428e-ae12-
d600560c2d6e@72g2000hsu.googlegroups.com:
I must confess I'm completely new to templates, having mainly used C++
for quite a while as 'C with Classes', but now I have an application
which seems to cry out for templates, but I just can't get my head
around how to use them in this situation. Any assistance or pointers
to other resources would be welcomed.
Let's say I have a (third party, unmodifiable) library of C functions
which provide the following interfaces:
int AAA_setup(const uint8_t* p1, int p2, struct context* p3);
int AAA_process(const uint8_t* p1, uint8_t* p2, struct context* p3);
int AAA_done(struct context* p1);
int BBB_setup(const uint8_t* p1, int p2, struct context* p3);
int BBB_process(const uint8_t* p1, uint8_t* p2, struct context* p3);
int BBB_done(struct context* p1);
int CCC_setup(const uint8_t* p1, int p2, struct context* p3);
int CCC_process(const uint8_t* p1, uint8_t* p2, struct context* p3);
int CCC_done(struct context* p1);
What I want to do is provide a class wrapper for all this so that in
my C++ application I can do something like:
Work<BBB> thing;
thing.setup(&data1, val);
thing.process(&in, &out);
thing.done();
(The pointer to the context structure can obviously disappear as
private data within the class)
Now this seems from my reading to be the sort of thing that templates
are probably good at, but I can't for the life of me see how to do it,
without first creating a separate class for each of AAA, BBB, and CCC.
Can anyone enlighten me please?
Sadly, this isn't ideal for templates, because templates works on types
and it seems that what you want is token concatenation. If things are
as you have it above, then it seems that a macro would be more
appropriate to generate the wrapper classes or create a class which
contains some function pointers and initialize that. Once you have your
functions wrapped in a class, then you can use templates to apply
algorithms to those classes.
As a side note, it does seem like both templates and macros are all
about code generation. Templates do it in a completely type safe manner
and macros in a manner that doesn't obey any scoping rules, but is
potentially useful anyway. It would be nice if templates could be
enhanced with some token pasting functionality so that stuff like this
could be safely expressed. Something like
template<token P>
class Work
{
Work() { P##setup(); }
~Work() { P##_done(); }
};
Then it could be instantiated with a token and the code generated. It
seems like it should be doable. Oh well, I could dream I suppose.
For the OP, the above does NOT work. Templates work with types and some
limited PODs but not arbitrary tokens or text.
joe