C++0x: Is this "this-parameter" forwarder for function<void(???)> correct?

[Johannes Schaub (litb)]

I read some discussion on how to best make

struct Class { void f() { } };
function<void(???)> f = bind(&Class::f, _1);

Class c;

work with both

f(&c);

and

f(c);

And I thought the following should work

template<typename T> struct ThisParam {
T *t;
ThisParam(T *t):t(t) { }
ThisParam(T &t):t(&t) { }

operator T*() const { return t; }
operator T&() const { return *t; }
};

function<void(ThisParam<Class>)> f = bind(&Class::f, _1);
Class a;
f(a);
f(&a);

But unfortunately, GCC doesn't like this. I thought the "operator T*" is
used by INVOKE(...)'s ((*t1).*f)(...). I supplied the "operator T&" in case
the user binds a function that wants a "Class&" as argument.

But GCC doesn't like the code when it has the "operator T&" - it only
accepts when i remove it. And I also find it confusing that it rejects when
I instead define it as follows and use it on a bound member function
pointer:

template<typename T> struct ThisParam {
T *t;
ThisParam(T *t):t(t) { }
ThisParam(T &t):t(&t) { }

T &operator *() const { return *t; }
};

Why is this? Do I misread 20.8.2[func.require] or is GCC's C++0x standard
library broken? Thanks for any insights!

 

[Niels Dekker - no reply address]

I read some discussion on how to best make
struct Class { void f() { } };
function<void(???)> f = bind(&Class::f, _1);
Class c;
work with both
f(&c);
and
f(c);

And I thought the following should work

template<typename T> struct ThisParam {
T *t;
ThisParam(T *t):t(t) { }
ThisParam(T&t):t(&t) { }

operator T*() const { return t; }
operator T&() const { return *t; }
};

function<void(ThisParam<Class>)> f = bind(&Class::f, _1);
Class a;
f(a);
f(&a);

But unfortunately, GCC doesn't like this. I thought the "operator T*" is
used by INVOKE(...)'s ((*t1).*f)(...). I supplied the "operator T&" in case
the user binds a function that wants a "Class&" as argument.

But GCC doesn't like the code when it has the "operator T&" - it only
accepts when i remove it. And I also find it confusing that it rejects when
I instead define it as follows and use it on a bound member function
pointer:

template<typename T> struct ThisParam {
T *t;
ThisParam(T *t):t(t) { }
ThisParam(T&t):t(&t) { }

T&operator *() const { return *t; }
};

Why is this? Do I misread 20.8.2[func.require] or is GCC's C++0x standard
library broken?

FWIW, I tried your code on both MSVC 2010 and GCC 4.5.1 20100924 (Red
Hat 4.6.1-4), after having added the necessary #include <functional> and
using-declarations: http://codepad.org/0F9Dls8G It compiled well on
MSVC 2010, but it failed on GCC 4.5.1 (g++ -std=c++0x). Just like you're
saying. :-(


My 2 cents, Niels