Re: Templates HowTo?

From:

"Alf P. Steinbach" <alfps@start.no>

Newsgroups:

comp.lang.c++

Date:

Thu, 21 Feb 2008 10:20:23 +0100

Message-ID:

<13rqgisndho28f9@corp.supernews.com>

* keith@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;
   };

   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;

Or something like that.

Cheers, & hth.,

- Alf

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?