C++Talk.NET

Longo Frank · Guest

I like the boost::function library for it’s very
concise and natural syntax. I recall an article in C++
Report by Rich Hickey (1994?) entitled “Callbacks in
C++ using Template Functors” which described a very
interesting technique that allowed functors to be held
by value just like built-in ptrs to functions. The
implementation didn’t require memory allocation nor
use any virtual functions. So I thought, what if we
put a boost::function frontend on a variation of
Hickey’s implementation? Here is my attempt which is
by no means suggested as a replacement for
boost::function but that I hope will inspire some
discussion on it’s own merits.

The basic idea is to have a non-parameterized base
class that is able to store (by value) a pointer to
function or method (and a reference to an object in
the case of pointer to method). This base class will
copy the bytes representing the pointer into a
character array.

Specializations of a parameterized subclass of this
base class will then provide compiler generated static
“translation” functions that will construct an
appropriate function or method pointer from the bytes
stored in the character array. This all becomes very
clear when you look at the code:

(And look Mom, no preprocessor macros! ;-)

struct function_base {
// to determine largest ptr-to-func size (no
storage)
class Unknown;
union FunctionPointer {
Unknown (*pf)(Unknown);
Unknown (Unknown::*pmf)(Unknown);
};

function_base( void *obj, void *funcptr, int
funcptr_size )
:_obj(obj)
{
if( funcptr_size != 0 )
memcpy( _funcptr, funcptr, funcptr_size );
}

char _funcptr[sizeof(FunctionPointer)];
void *_obj;
};

template <typename FUNC>
struct function {};

Following is a specialization of function<> for
functions of the general form RET (*)(ARG) taking 1
argument and having a return value. There is 1
constructor for member functions and 1 for non-member
functions that are parameterized on function pointer
type (there is also a default ctor). The single member
variable _translator will be initialized to point to
one of many nested static translator functions with
the help of a specialized nested translator class
template.

template <typename RET, typename ARG1>
class function<RET(ARG1)>: function_base {
template <class FUNC> struct static_translator {};

// A translator for non-member functions.
template <typename RETN, typename ARG1N>
struct static_translator<RETN (*)(ARG1N)> {
static RET translator( const function_base& fbase,
ARG1 arg1 ){
RETN (*f)( ARG1N );
memcpy( &f, fbase._funcptr, sizeof f );
return (*f)( arg1 );
}
};

// a translator for member functions
template <class OBJECT, typename RETN, typename
ARG1N>
struct static_translator<RETN (OBJECT::*)(ARG1N)> {
static RET translator( const function_base& fbase,
ARG1 arg1 ){
RETN (OBJECT::*f)(ARG1N);
OBJECT *obj =
reinterpret_cast<OBJECT*>(fbase._obj);
memcpy( &f, fbase._funcptr, sizeof f );
return (obj->*f)( arg1 );
}
};

RET (*_translator)( const function_base&, ARG1 );

public:
function()
:function_base( 0, 0, 0 )
{}

template <class FUNC>
function( FUNC func )
:function_base( 0, &func, sizeof func )
,_translator( static_translator<FUNC>::translator
)
{}

template <class OBJECT, class FUNC>
function( OBJECT& obj, FUNC func )
:function_base( &obj, &func, sizeof func )
,_translator( static_translator<FUNC>::translator
)
{}

RET operator()( ARG1 arg1 ){ return (*_translator)(
*this, arg1 ); }
};

Finally usage is similar to boost::function:

int foo(double);
bool bar(int);

struct Foo {
bool bar(double);
};

…

function<bool(int)> f = bar;
f(3);

Foo afoo;
function<bool(double)> f2( afoo, &Foo::bar );
f2(22/7.0);

f2 = foo;
f2(3.14);

------------------
Frank Longo
[email]longof2 (AT) yahoo (DOT) com[/email]

__________________________________
Do you Yahoo!?
Yahoo! SiteBuilder - Free, easy-to-use web site design software
http://sitebuilder.yahoo.com

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

Stefan Heinzmann · Guest

Longo Frank <longof2 (AT) yahoo (DOT) com> wrote

Shay · Guest

In article <95e0e5ef.0308270327.4772d003 (AT) posting (DOT) google.com>,
[email]stefan_heinzmann (AT) yahoo (DOT) com[/email] (Stefan Heinzmann) wrote:

Frank Longo · Guest

blargg (AT) mail (DOT) c0m (Shay) wrote in message news:<blargg-2708031724540001 (AT) aus-as2-037 (DOT) io.com>...