Re: Bound member functions
On Dec 3, 2:23 pm, AlbertoBarb...@libero.it (Alberto Ganesh Barbati)
wrote:
Sean Hunt ha scritto:
Overloading of the ->* operator is a good reason. In a smart pointer
class (assuming T is the type pointed to, ptr is pointer being
wrapped.):
template <typename U>
inline auto operator ->* (U T::* p) // Sorry if I got the syntax
wrong. You get the idea, right?
-> ptr->*p
I guess you mean
-> decltype(ptr->*p)
I guess. I was under the impression that the -> mean an implicit
decltype (because "-> int" would be stupid. You could just have
declared that as the normal type).
{
if (!ptr)
throw myCustomException;
return ptr->*p;
}
Without a bound member function as a type, this won't work. Any other
solution simply won't cover the full range of possibilities that can
be done with this, such as ensuring all operators work for any type.
Yes, that's precisely one use case and a very good one.
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.
return a reference, which I overlooked, but more importantly, operator
->* can be implemented using type traits, but it's difficult:
template <typename U, bool b = std::is_function<U>>
U& operator ->* (U T::* p)
{
return ptr->*p;
}
template <typename U>
auto operator ->*<U, true> (U T::* p)
-> std::bind(std::mem_fn(p), ptr)
Again, you missed the decltype here.
Fair enough.
{
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.
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.
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.
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.
Sean
---
[ 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 ]