Re: Bound member functions
Sean Hunt ha scritto:
On Dec 3, 2:23 pm, AlbertoBarb...@libero.it (Alberto Ganesh Barbati)
wrote:
Sean Hunt ha scritto:
I'd like to correct myself twice here. First, it should probably
return a reference, which I overlooked, [...]
No. According to my proposal, decltype(ptr->*p) is a type than can be
safely copied and should actually returned by value.
But in order to return an lvalue, it must return a reference.
Otherwise:
foo->*p = 3;
would be incorrect.
There must be a misunderstanding. My idea was only about binding member
*functions* (as the subject of this post should have suggested). I was
not considering data members.
{
return std::bind(std::mem_fn(p), ptr)
}
the call to mem_fn is actually unnecessary. you can simply write
std::bind(p, ptr).
std::bind binds argument types. Not the implicit object parameter,
unless I have dearly misunderstood the function.
I don't understand what you mean by that, but I can assure that
bind(mem_fn(p), ptr)
and
bind(p, ptr)
are equivalent whenever p is a pointer to member function.
Anyway, your example is good for member functions that has exactly no
parameters. What if they have some? Let's rewrite the example, the
difference is minimal:
U can be typed to a specific function or to any non-function type the
way I wrote it. It doesn't matter if it's int(U)(int, float) or myType
U. It always works.
It may compile, but it doesn't "work" in the general case. The problem
is that std::bind(p, ptr) returns an object B such that
B(a1, a2, ... aN)
eventually resolves to:
(ptr->*p)();
regardless of N, so the member function identified by p must be callable
without parameters.
template <typename U, typename... Args>
inline auto operator ->* (U (T::*p)(Args...))
-> decltype(ptr->*p)
{
return ptr->*p;
}
(notice that you no longer need to rely on std::is_function nor on
std::bind)
Hmm... I don't think that you can specialize for any sort of function
type:
template <typename U, typename V = char, typename Args...> class foo
{ ... };
template <typename V, typename Args...> class foo <V U (Args...)>
{ ... };
I'm pretty sure that doesn't work, so the type_traits is the only way
to determine the presence of a functional type.
What you wrote (with functions) doesn't work, but what I wrote (with
pointer to member functions) should. At least it does without template
argument packs and I don't see why it shouldn't with them.
I challenge you to rewrite the same code with std::bind. You need to
convert the template argument pack Args to a sequence of placeholders
_1, _2, etc. There may be MPL techniques able to do that, but I bet that
it's going to be painful.
You misunderstand operator->*. It simply returns an object. In the
expression (foo->*p)(i), the result of operator ->* is called with the
parameter i. As a result, I must return an object that is suitable for
a call with i (but not necessarily anything else) when I get a pointer
to function, but when I get a pointer to object, I must return it as
an lvalue.
I repeat, my post was only about pointer to member functions, not
pointer to data members.
Anyway what you say is incorrect. *For member functions* the standard
currently says that ->* does *not* return an object, but returns a
function (see 5.5/3). Indeed *I* am proposing to change that and make
->* return a callable object instead.
Ganesh
PS: A function is *not* an object (see 1.8/1).
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]