Re: Call a member function only if it exists

From:

Carl Barron <cbarron413@adelphia.net>

Newsgroups:

comp.lang.c++.moderated

Date:

Thu, 3 Jan 2008 20:19:18 CST

Message-ID:

<020120080117164293%cbarron413@adelphia.net>

In article
<80d4aa91-f16a-4772-a622-b184fcc63220@v4g2000hsf.googlegroups.com>,
Jens Breitbart <jbreitbart@gmail.com> wrote:

Hi,

I wrote a framework, which uses callback functions. Currently all
classes used with the framework have to implement the callback
function. I would like to define a default behavior for all classes,
that do not implement the function. I am aware that this could easily
be done, by defining a base class and require that all classes used
with the framework inherit for this base class, but I would prefer to
do this without inheritance. The code I have in mind looks similar to
the one below, but I failed to write the caller template.

void f () {
// default behavior
}

struct A {
void f () {
// special behavior for objects of type A
}
};

struct B {
};

int main () {
A a;
B b;

//caller<A>::f(a); // should call a.f()
//caller<B>::f(b); // should call f()

return 0;
}

Something like the following ???
#include <iostream>

// an empty base class
// used if none exists for f_base
struct None{};

// a struct that inherits what the derived class
// inherits from [None can be used if none really
// exists]
template <class Base>
struct f_base:Base
{
   void f()
   {
      std::cout << "Default behavior\n";
   }
};

// helper template avoids typing type passed.
template <class T>
void call_f(T &a) { a.f();}

// end of general code.
struct A:f_base<None>
{
};

struct B:f_base<None>
{
   void f() {std::cout << "B's behavior\n";}
};

struct C
{
   virtual void g()=0;
   virtual ~C(){}
};

struct D:f_base<C>
{
   void g() {f();}
};

struct E:f_base<C>
{
   void f() {std::cout << "E's behavior\n";}
   void g() {f();}
};

int main()
{
   A a;
   B b;
   D d;
   E e;

   C *p = &d;
   C *q = &e;
   std::cout << "non_virtual calls\n";
   call_f(a);
   call_f(b);
   call_f(d);
   call_f(e);
   std::cout << "virtual calls\n";
   p->g();
   q->g();
}
it produces:
non_virtual calls
Default behavior
B's behavior
Default behavior
E's behavior
virtual calls
Default behavior
E's behavior

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]