Re: Templates HowTo?
On Feb 21, 10:20 am, "Alf P. Steinbach" <al...@start.no> wrote:
* ke...@bytebrothers.co.uk:
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?
Each of group AAA, BBB and CCC essentially constitute a functor object.
class AbstractWork
{
public:
virtual ~AbstractWork() {}
virtual int operator( whatever ) = 0;
};
You've lost me there. Each group proposes three functions, not
one. (And you never use AbstractWork later, either. Is it
maybe part of an idea you had to start with, that didn't pan
out, and you forgot to delete it?)
struct CFunctionTypes
{
typedef (*SetupFunc)
(const uint8_t* p1, int p2, struct context* p3);
typedef (*ProcessFunc)
(const uint8_t* p1, uint8_t* p2, struct context* p3);
typedef (*DoneFunc)
(struct context* p1);
};
struct AAAFunctions: CFunctionTypes
{
static SetupFunc const setup;
static ProcessFunc const process;
static DoneFunc const done;
};
CFunctionTypes::SetupFunc const AAAFunctions::setup = &AAA_setup;=
CFunctionTypes::ProcessFunc const AAAFunctions::process = &AAA_setup;=
CFunctionTypes::DoneFunc const AAAFunctions::done = &AAA_done;
template< class CFunctions >
class WorkWrapper
{
protected:
context myContext;
public:
WorkWrapper( uint8_t a, int b )
{
if( !CFunctions::setup( &a, b, &myContext ) )
{ throwX( "urk" ); }
}
virtual ~WorkWrapper() { CFunctions::done( &myContext ); }
virtual int operator( whatever )
{
return CFunctions::process( ..., ..., &myContext );
}
};
typedef WorkWrapper<AAAFcuntions> AAAWork;
That's actually pretty clever. I'll admit that as soon as I saw
the C style naming convention, macros and token pasting came to
mind---I probably used <generic.h> too much in the old days.
A pure macro solution probably takes less typing, but if I were
to use macros, I'd definitly use an abstract base class and
factory functions in order to avoid having to define a macro in
the client header (and thus poluting the clients namespace).
Which, of course, results in more lines of code (but might have
other advantages as well, so that you'd want to use it anyway).
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34