Re: Templates HowTo?
On Feb 21, 9:42 am, ke...@bytebrothers.co.uk wrote:
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.
It's not templates you need, but macros. Something like:
class AbstractWork : private context
{
public:
virtual ~AbstractWork() {}
virtual int setup( uint8_t const* p1, int p2 ) = 0 ;
virtual int process( uint8_t const* p1, uint8_t* p2 )
= 0 ;
virtual int done() = 0 ;
} ;
#define Whatever( prefix )
class Work ## prefix : public AbstractWork
{
public:
virtual int setup( uint8_t const* p1, int p2 )
{
return prefix ## _setup( p1, p2, this ) ;
}
virtual int _process( uint8_t const* p1, uint8_t* p2 )
{
return prefix ## process( p1, p2, this ) ;
}
virtual int _done()
{
return prefix ## done( this ) ;
}
}
Whatever( AAA ) ;
Whatever( BBB ) ;
Whatever( CCC ) ;
The abstract base class may or may not be necessary at the
interface level---in this case, it's also handy for maintaining
the context structure; if you provide the necessary factory
functions in the file which defines the concrete classes, it
will also prevent the macro name from poluting the client code.
(E.g. put the definition of the abstract class in a header file,
along with the declarations of the factory functions, and just
define the macro in an implementation file which invokes it.)
--
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