468,784 Members | 1,561 Online
Bytes | Developer Community
New Post

Home Posts Topics Members FAQ

Post your question to a community of 468,784 developers. It's quick & easy.

Overloading -> and ->*

Can't understand how to overload these operations and for what reason?
Jul 22 '05 #1
8 1521

"maths_fan" <ma*******@mail.ru> wrote:
Can't understand how to overload these operations and for what reason?


Can't understand your question real well either. Do you think you could
write it a little more clearly?

You overload these operators like any other operator. operator->() is
typically overloaded to implement smart pointers. A good example of a
reference-counting smart pointer, which demonstrates how to overload
operator->(), appears in the FAQ:

http://www.parashift.com/c++-faq-lit...html#faq-16.21

Of course, I'm sure you consulted the FAQ before posting any questions here,
right?

Overloading the pointer to member operator (->*) is done a lot less
frequently, but again is used to implement smart pointers.

Best regards,

Tom
Jul 22 '05 #2

"maths_fan" <ma*******@mail.ru> wrote in message
news:c1*************************@posting.google.co m...
Can't understand how to overload these operations and for what reason?


1.
struct X
{
Y* operator->();
}

2. (the not obvious bit)
Because the compiler will reapply -> to the result.
This allows smart pointers, lazy construction, locking and much more.

2a. I've never come across a reason to overload ->*
Jul 22 '05 #3
Nick Hounsome wrote:
1.
struct X
{
Y* operator->();
}

2. (the not obvious bit)
Because the compiler will reapply -> to the result.
This allows smart pointers, lazy construction, locking and much more.


I've had some problems with this in the past.

My compiler was Codewarrior, and the fix was to do
(*myIterator)->MethodCall();

This was with not-std:: containers, but is this basically telling
me that I *should* be able to have a container of pointers to
objects, and do iterator->call() and have it bounce through
operator->() implementations 'til it gets to the end? Are there
any gotchas that I may not have been aware of that would prevent
this from happening correctly?

thx,
-tom!
Jul 22 '05 #4
Tom Plunket wrote in news:e2********************************@4ax.com:
Nick Hounsome wrote:
1.
struct X
{
Y* operator->();
}

2. (the not obvious bit)
Because the compiler will reapply -> to the result.
This allows smart pointers, lazy construction, locking and much more.


I've had some problems with this in the past.

My compiler was Codewarrior, and the fix was to do
(*myIterator)->MethodCall();

This was with not-std:: containers, but is this basically telling
me that I *should* be able to have a container of pointers to
objects, and do iterator->call() and have it bounce through
operator->() implementations 'til it gets to the end? Are there
any gotchas that I may not have been aware of that would prevent
this from happening correctly?


Yes, if you have:

#include <vector>

struct X
{
int x;
};

int main()
{
X x;
std::vector< X * > xpv( 10, &x );
std::vector< X * >::iterator ptr = xpv.begin();
}

Then ptr.operator -> () will return an X**, not an X*.

If you try ptr->x, the compiler will call ptr.operator -> () and
then try to apply the inbult (X**)->x, however there is no such
operator, inbult opertor -> *only* applies to pointers to struct's (*)
and X** is a pointer to a pointer not a pointer to a struct.

*) by 'struct' I mean aggragate i.e, struct, class or union.

So the Gotcha would be "there is no inbuilt operator -> for T**".

Rob.
--
http://www.victim-prime.dsl.pipex.com/
Jul 22 '05 #5
Rob Williscroft wrote:
struct X
{
int x;
};

int main()
{
X x;
std::vector< X * > xpv( 10, &x );
std::vector< X * >::iterator ptr = xpv.begin();
}

Then ptr.operator -> () will return an X**, not an X*.

If you try ptr->x, the compiler will call ptr.operator -> () and
then try to apply the inbult (X**)->x, however there is no such
operator, inbult opertor -> *only* applies to pointers to struct's (*)
and X** is a pointer to a pointer not a pointer to a struct.

*) by 'struct' I mean aggragate i.e, struct, class or union.

So the Gotcha would be "there is no inbuilt operator -> for T**".


So this is to say if I had:

std::vector< boost::shared_ptr<X> >::iterator it;
it->x = 3;

would compile properly?

I think I get it. I was reading previous information on this
topic to suggest that there *was* a built-in operator-> that was
triggered that would "do what you expect," although now that I
think about it it seems obviously wrong since you wouldn't (?)
want:

X** x;
x->x = 5;

to compile.

thanks-
-tom!
Jul 22 '05 #6
Tom Plunket wrote in news:mp********************************@4ax.com:
Rob Williscroft wrote:
[snip]

So the Gotcha would be "there is no inbuilt operator -> for T**".


So this is to say if I had:

std::vector< boost::shared_ptr<X> >::iterator it;
it->x = 3;

would compile properly?


Alas it doesen't, it.operator ->() returns a boost::shared_ptr<X> *.

it->x would work if the return value was shared_ptr<X> &, but
then std::vector's of simple structs wouldn't work.

Also you couldn't do: it->unique() (*).

*) For those that don't know, unique() is a member of shared_ptr<>:

http://www.boost.org/libs/smart_ptr/shared_ptr.htm.
I think I get it. I was reading previous information on this
topic to suggest that there *was* a built-in operator-> that was
triggered that would "do what you expect," although now that I
think about it it seems obviously wrong since you wouldn't (?)
want:

X** x;
x->x = 5;

to compile.


Rob.
--
http://www.victim-prime.dsl.pipex.com/
Jul 22 '05 #7
Rob Williscroft wrote:
So this is to say if I had:

std::vector< boost::shared_ptr<X> >::iterator it;
it->x = 3;

would compile properly?


Alas it doesen't, it.operator ->() returns a boost::shared_ptr<X> *.


Oh...

I fail to see now, then, where this operator-> does this bouncing
then... When does it, when can it, come up?
-tom!
Jul 22 '05 #8
Tom Plunket wrote in news:sq********************************@4ax.com:
Rob Williscroft wrote:
> So this is to say if I had:
>
> std::vector< boost::shared_ptr<X> >::iterator it;
> it->x = 3;
>
> would compile properly?
>


Alas it doesen't, it.operator ->() returns a boost::shared_ptr<X> *.


Oh...

I fail to see now, then, where this operator-> does this bouncing
then... When does it, when can it, come up?


#include <iostream>
#include <ostream>

using std::cerr;

//Simple case

struct X
{
int data;
};

struct Y
{
X *xp;
X *operator -> () { return xp; }
};

void simple_example()
{
X x = { 0 };
Y y = { &x };
y->data = 1;

cerr << x.data << '\n';
}

/* y->data calls y.operator ->() which returns X*,
compiler uses inbuilt operator ->.
*/

//Complex case:

struct Z
{
Y array[2];
bool b;

/* Note: operator -> () returns a reference not a pointer
*/
Y & operator -> () { return array[b]; }
};

void complex_example()
{
X x1 = { 0 }, x2 = { 0 };
Z z = { { &x1, &x2 }, false };

z->data = 1;
z.b = true;
z->data = 2;
cerr << x1.data << '\n';
cerr << x2.data << '\n';
}

/* z->data calls x.operator -> () which returns Y &,
compiler calls Y::operator -> (), which returns X *,
compiler uses inbuilt operator ->.
*/
int main()
{
simple_example();
complex_example();
}

In short bouncing as you call it continues until a user defined
operator -> () returns a pointer, and then the language's inbuilt
rules are applied.

Rob.
--
http://www.victim-prime.dsl.pipex.com/
Jul 22 '05 #9

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

3 posts views Thread by TJ | last post: by
2 posts views Thread by franklini | last post: by
6 posts views Thread by n2xssvv g02gfr12930 | last post: by
6 posts views Thread by iLL | last post: by
2 posts views Thread by Colonel | last post: by
reply views Thread by zhoujie | last post: by
2 posts views Thread by Marin | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.