C++Talk.NET

Howard Gardner · Guest

/*
I'm trying to figure out how to call a class member function using a
pointer to the member function and either a real pointer to the class or
a smart pointer to the class. So far, I've been unable to find the
syntax that I need. I have hacked together a solution that I think I
could use, and that doesn't require that syntax, but the solution is
unlovely and I'd much prefer to find the syntax.

There is one significant constraint: I want to use operator ->() in the
smart pointer, because I intend to exploit the "temporary's lifetime
benefit." If I can't get to that benefit, then there's no reason for me
to write the code that requires this syntax in the first place.

I'd obviously like to avoid burdening either the class or the smart
pointer with any additional syntax if at all possible: the solution that
I hacked together manages to do this, at least as far as I've taken it.
If theres a clean solution that burdens the smart pointer--for instance,
writing operator ->*()--then that might be ok. Burdening the class just
won't do.

Lastly, the signature of the member function is not an issue. In the
context in which I want to make this call, that signature is known. In
other words, if you can show me how to make the sample code below work,
then I can handle the rest of the problem.

The missing syntax is--well--missing. I've commented out a couple of
things that won't do.

**

The "temporary's lifetime benefint" is the fact that operator ->() can
return something that is not really a pointer to the pointee, and which
has a really useful lifetime.

Alexandrescu mentions this in "Modern C++ Design, section 7.3", and
elaborates on its potential utility in multithreaded applications in
"Modern C++ Design, section 7.13.1".

Alexandrescu refers to Stroustrup's paper "Wrapping Calls to Member
Functions", which was published in C++ Report in June of 2000. This
paper appears to be available on the web at:

http://www.research.att.com/~bs/wrapper.pdf

Stroustrup also deals with the topic in "The C++ Programming Language,
section 11.10."

**

*/

#include <iostream>
using namespace std;

// Some random class that has a member function
struct example
{
void mem_func() const
{cout << "example::mem_func" << endl;}
};

// A deliberately minimalist "smart pointer"
template < typename xPointee >
struct ptr
{
typedef ptr tSelf;
typedef xPointee tPointee;
typedef xPointee * tPointer;

ptr(const tSelf & fThat)
:cPointer(fTHat.cPointer)
{cout << "ptr::copy" << endl;}

explicit
ptr(tPointer fPointer)
:cPointer(fPointer)
{cout << "ptr::conversion" << endl;}

~ptr()
{cout << "ptr::destructor" << endl;}

tPointee operator *()
{cout << "ptr::operator *()" << endl; return *cPointer;}

tPointer operator ->()
{cout << "ptr::operator ->()" << endl; return cPointer;}

tPointer cPointer;
};

// An attempt to call a member mem_function through either a smart
// pointer or a pointer
template < typename xPtrLike, typename xPtrMemFunc >
void
call(xPtrLike fPtrLike, xPtrMemFunc fPtrMemFunc)
{
cout << "call" << endl;

// Next line works fine, but I lose the "temporary lifetime benefit"
// ((*fPtrLike).*fPtrMemFunc)();

// Next line works for a real pointer, but not ptr< >
// (fPtrLike->*fPtrMemFunc)();
}

int main()
{
example fExample;
call(&fExample, &example::mem_func);
cout << endl;
call(ptr< example >(&fExample), &example::mem_func);
}

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

Ivan Vecerina · Guest

"Howard Gardner" <usenet (AT) hgardner (DOT) com> wrote

Hi,

Joseph Seigh · Guest

On 29 Jan 2005 23:10:34 -0500, Howard Gardner <usenet (AT) hgardner (DOT) com> wrote:

Howard Gardner · Guest

/*
I dont' have access to that article. I presume that his solution looks
pretty much like this version, which is based on overloading global
operator ->*?

I added lck<>, which simulates the locking behavior that motivates
me, but also simulates other interesting behavior (ie, some other
reason for wrapping a member function call).

On the plus side, this doesn't intrude on either ptr<> or example,
and the syntax in call<> is uniform.

It doesn't let me get to the temporary's lifetime benefit, though, so
it's no good to me.

Interestingly, the lifetime of the proxy that operator ->* returns is
also correct for my purposes. Annoyingly, that doesn't appear to do me
much good: what I am trying to do is exploit the temporary's lifetime
benefit given a canonical implementation of a smart pointer.

The fact that global operator ->* has to be so tightly coupled to ptr<>
(uses its name in deduction, and uses its typedef tPointee) is also
unfortunate.

When run, this program produces the output:

ptr::ptr(tPointer)

correctly locked
ptr::operator ->
lck::lck(tPointer) - *LOCK*
lck::operator ->
example::mem_func - *USE*
lck::~lck - *UNLOCK*

real pointers still work
call
example::mem_func - *USE*

smart pointers work too ... kindof
ptr::ptr(tSelf)
call
ptr::ptr(tSelf)
operator ->*
proxy::proxy(tPointer, tPtrMemFunc)
proxy::operator ()
example::mem_func - *USE*
proxy::~proxy
ptr::~ptr
ptr::~ptr

ptr::~ptr
*/

#include <iostream>
using namespace std;

// Some random class that has a member function
struct example
{
void mem_func() const
{cout << "example::mem_func - *USE*" << endl;}
};

// A "locking pointer"
template < typename xPointee >
struct lck
{
typedef lck tSelf;
typedef xPointee tPointee;
typedef xPointee * tPointer;

lck(const tSelf & fThat)
:cPointer(fThat.cPointer)
{cout << "lck::lck(tSelf) - *LOCK*" << endl;}

explicit
lck(tPointer fPointer)
:cPointer(fPointer)
{cout << "lck::lck(tPointer) - *LOCK*" << endl;}

~lck()
{cout << "lck::~lck - *UNLOCK*" << endl;}

tPointee operator *() const
{cout << "lck::operator *" << endl; return *cPointer;}

tPointer operator ->() const
{cout << "lck::operator ->" << endl; return cPointer;}

tPointer cPointer;
};

// A deliberately minimalist "smart pointer"
template < typename xPointee >
struct ptr
{
typedef ptr tSelf;
typedef xPointee tPointee;
typedef xPointee * tPointer;
typedef lck< tPointee > tLck;

ptr(const tSelf & fThat)
:cPointer(fThat.cPointer)
{cout << "ptr::ptr(tSelf)" << endl;}

explicit
ptr(tPointer fPointer)
:cPointer(fPointer)
{cout << "ptr::ptr(tPointer)" << endl;}

~ptr()
{cout << "ptr::~ptr" << endl;}

tPointee operator *() const
{cout << "ptr::operator *" << endl; return *cPointer;}

tLck operator ->() const
{cout << "ptr::operator ->" << endl; return tLck(cPointer);}

tPointer cPointer;
};

// A nullary functor to be returned by overloaded global operator ->*
template < typename xPointee, typename xResult >
struct proxy
{
typedef proxy tSelf;
typedef xPointee tPointee;
typedef xResult tResult;

typedef tPointee * tPointer;
typedef tResult (tPointee::*tPtrMemFunc)() const;

proxy(const tSelf & fThat)
: cPointer(fThat.cPointer), cPtrMemFunc(fThat.cPtrMemFunc)
{cout << "proxy::proxy(tSelf)" << endl;}

proxy(tPointer fPointer, tPtrMemFunc fPtrMemFunc)
: cPointer(fPointer), cPtrMemFunc(fPtrMemFunc)
{cout << "proxy::proxy(tPointer, tPtrMemFunc)" << endl;}

~proxy()
{cout << "proxy::~proxy" << endl;}

tResult operator()() const
{
cout << "proxy::operator ()" << endl;
return (cPointer->*cPtrMemFunc)();
}

tPointer cPointer;
tPtrMemFunc cPtrMemFunc;
};

// overloaded global operator ->*
template < typename xPtr, typename xResult >
proxy< typename xPtr::tPointee, xResult >
operator ->*(xPtr fPtr, xResult (xPtr::tPointee::*fPtrMemFunc)() const)
{
typedef xPtr tPtr;
typedef xResult tResult;
typedef typename tPtr::tPointee tPointee;
typedef proxy< tPointee, tResult > tProxy;
cout << "operator ->*" << endl;
return tProxy(fPtr.cPointer, fPtrMemFunc);
}

// An attempt to call a member function through either a pointer
// or a smart pointer
template < typename xPtrLike, typename xPtrMemFunc >
void
call(xPtrLike fPtrLike, xPtrMemFunc fPtrMemFunc)
{
cout << "call" << endl;

// If used on a real pointer, this does just what it appears to do.
// If used on a ptr<>, this first calls the overloaded global
// operator ->*, then immediately calls operator () on the proxy that
// was returned.
(fPtrLike->*fPtrMemFunc)();
}

int main()
{
example fExample;
ptr< example > fPtr(&fExample);
cout << endl;

cout << "correctly locked" << endl;
fPtr->mem_func();
cout << endl;

cout << "real pointers still work" << endl;
call(&fExample, &example::mem_func);
cout << endl;

cout << "smart pointers work too";
cout << " ... kindof" << endl;
call(fPtr, &example::mem_func);
cout << endl;
}

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

Howard Gardner · Guest

Joseph Seigh wrote:

Ivan Vecerina · Guest

"Howard Gardner" <usenet (AT) hgardner (DOT) com> wrote

Howard Gardner · Guest

/*
Victory!

This version:

1) does not intrude on either example or ptr<>.
2) depends only on ptr<> having an operator->() defined.
3) gets me to the temporary's lifetime benefit.

I can retrofit other people's smart pointers this way!

I think that this solution is valid for calling any member function that
takes zero parameters, and feel confident that I can extend it to cover
higher arities (my library, The UFO, is only concerned with arities up
to 3 at this point).
*/

#include <iostream>
using namespace std;

// Some random class that has a member function
struct example
{
int mem_func() const
{cout << "example::mem_func" << endl; return 42;}
};

// A deliberately minimalist "smart pointer"
template
<
typename xPointee,
typename xPointer = xPointee *,
typename xStorage = xPointee *

Joseph Seigh · Guest

On 31 Jan 2005 19:40:18 -0500, Howard Gardner <usenet (AT) hgardner (DOT) com> wrote:

David Abrahams · Guest

Howard Gardner <usenet (AT) hgardner (DOT) com> writes:

Howard Gardner · Guest

David Abrahams wrote:

Howard Gardner · Guest

Joseph Seigh wrote:

Joseph Seigh · Guest

On 2 Feb 2005 04:55:11 -0500, Howard Gardner <usenet (AT) hgardner (DOT) com> wrote:

David Abrahams · Guest

Howard Gardner <usenet (AT) hgardner (DOT) com> writes: