Callbacks and derived classes in C++

Wednesday, June 7. 2006

Callbacks and derived classes in C++

I just created a pretty neat callback mechanism for C++:

template<typename T>
class callback {
public:
callback(T* obj, unsigned int (T::*func)(string, ostream&, header_container&, cgiparam_container& ))
: callee(obj), cb(func) { }
~callback();
unsigned int run(string actionstr, ostream& os, header_container& hdrs, cgiparam_container& params) {
return (callee->*cb)(actionstr,os,hdrs,params);
}
private:
T* callee;
unsigned int (T::*cb) (string,ostream&, header_container&, cgiparam_container& );
};
class context {
public:
context();
~context();
unsigned int dispatch_action(string actionstr, ostream& os, header_container& hdrs, cgiparam_container& cgiparams);
protected:
void register_action(string,callback<context>*);
private:
map<string,callback<context>*> actions;
};

The implementation of register_action() looks like this:

void context::register_action(string action, callback<context>* cb) {
actions[action] = cb;
}

And this is used in the following way (called from within the context class):

register_action("foobar",new callback<context>(this,&context::some_method));

Now, the problem that I have is that that adding callbacks that are not actually within the context class but within a derived class is only possible with lots of ugly casting (but it seems to work afterwards):

#define REGISTER_ACTION(name,action) do { register_action((name),new callback<context>((context*)this, (unsigned int (context::*)(std::string, std::ostream&, net::header_container&, net::cgiparam_container&))&action)); } while(0)

Do I see correctly that C++ seems to have certain problems with derived classes and templates, especially when it comes to using pointers to methods? Any input is welcome on how to remove this ugly casting while keeping the same functionality.

Posted by Andreas Krennmair at 21:06 | Comments (5) | Trackback (1)

Defined tags for this entry: c++, problem, programming

Related entries by tags:

Trackbacks

Trackback specific URI for this entry

HTTP stack used for flexible HTTP platform
In the last few days, I was working hard to finish a first working version of my "cwapd" (totally uninspired name, I know, it's supposed to mean "C++ Web Application Platform Daemon"). It is based on my previously-mentioned HTTP stack. The basic concep

Weblog: AK's weblog
Tracked: Jun 09, 20:22

Comments

Display comments as (Linear | Threaded)

warning - Unhelpful comment... Anyway, it's some time ago since I did C++ but why do you do the
do { ... } while(0)
in the macro? If you want to create a new scope for the statements simply
{ ... }
should do the job (or I'm confusing this with Java).
Sorry that I can't help you with the template problem and thanks for reminding me how great it is that I can use Java in my current projects

#1 David (Homepage) on 2006-06-07 23:48 (Reply)

That's the proper way of implementing a multistatement macro in C/C++. The comp.lang.c FAQ has more details about it: http://c-faq.com/cpp/multistmt.html

#1.1 ak (Homepage) on 2006-06-08 05:32 (Reply)

Thanks, I didn't know that. I just looked it up in the C++ grammar [1], and C++ should recognize "{};". Also,
the following program compiles without error or warning with g++:

int main(int argc, char **argv) {
{}; return 0;
}

[1] "Die C++ Programmiersprache" (The C++ Programming Language), Bjarne Stroustrup, Appendix A

#1.1.1 David (Homepage) on 2006-06-08 15:36 (Reply)

Sorry, my fault. Of course my example is illegal. And I looked up the wrong definitions in the grammar - I am a bad compiler

- so you're right. Best way to to mulit-statement macros.

#1.1.1.1 David (Homepage) on 2006-06-08 15:49 (Reply)

template <typename T>
class context {
void register_action(string, callback<T> * );
map<string, callback<T> *> actions;
};

class derived : public context<derived> {
};

so gehts auch ohne casten, weil eine methode in context auch als (derived::*)() gefunden wird.

das pattern mit dem public context<derived> heisst "curiously recurring template pattern".

selbst in der context klasse kann man
T::*method schreiben, um auf eine methode der context-klasse zu pointen, weil die methoden von context an T (oder derived in diesem fall) vererbt werden.

uebrigens ist callback::callee wharscheinlich immer identisch mit this in context::dispatch_action, oder?

eine heapallokation solltest du auch vermeiden und eine map<string, callback<T> > verwenden

#2 root@nobody.com (Homepage) on 2006-06-17 20:43 (Reply)

Add Comment

Name
Email
Homepage
In reply to
Comment	Enclosing asterisks marks text as bold (word), underscore are made via _word_. Standard emoticons like :-) and ;-) are converted to images. You can use [geshi lang=lang_name [,ln={y\|n}]][/geshi] tags to embed source code snippets. To prevent automated Bots from commentspamming, please enter the string you see in the image below in the appropriate input box. Your comment will only be submitted if the strings match. Please ensure that your browser supports and accepts cookies, or your comment cannot be verified correctly. Enter the string from the spam-prevention image above:
	Remember Information? Subscribe to this entry