operator overloand and .*

[flopbucket]

Hi,

I know that .* can not be overloaded but I am looking for some
background information for this. I have no need or desire to overload
it, but I am just curious from an educational point of view.

And what does this exactly refer to? Is it .* as in:

struct foo
{
int *bar;
}

int val = foo.*bar;

Or is there some other case when .* is used? Curious as to the reasons
why it can not be overloaded. I did not realize that .* is an operator
itself, I always thought of . * as two different operators (i.e. as in
the the above example).

Thanks

[Victor Bazarov]

flopbucket wrote:

I know that .* can not be overloaded but I am looking for some
background information for this. I have no need or desire to overload
it, but I am just curious from an educational point of view.

And what does this exactly refer to?
It's called "member access through a pointer to member" (or some such).

struct foo {
int a;
int b;
};

int main() {
foo f;
int foo::*pmem = &foo::a;
f.*pmem = 42; // same effect as f.a = 42;
pmem = &foo::b;
f.*pmem = 42; // same effect as f.b = 42;
}
Is it .* as in:

struct foo
{
int *bar;
}

int val = foo.*bar;
That should be a syntax error.
Or is there some other case when .* is used? Curious as to the
reasons why it can not be overloaded. I did not realize that .* is
an operator itself, I always thought of . * as two different
operators (i.e. as in the the above example).

What book are you reading that doesn't explain pointers to members?

As to *why* certain things the way they are, read "Design and Evolution
of C++" by Stroustrup, plenty of things are explained there. I bet you
could also find answers to "why some operators cannot be overloaded" on
the web.

V
--
Please remove capital As from my address when replying by mail

[Rolf Magnus]

flopbucket wrote:

Hi,

I know that .* can not be overloaded but I am looking for some
background information for this. I have no need or desire to overload
it, but I am just curious from an educational point of view.

And what does this exactly refer to? Is it .* as in:

struct foo
{
int *bar;
}

int val = foo.*bar;
No. That would have to be

int val = *foo.bar;
Or is there some other case when .* is used?

It is for pointers to members, like:
struct foo
{
int bar;
};

int foo::* val = &foo::bar;

foo f;
f.*val = 3;

This is rarely used with pointers to member variables, because you can also
use a normal pointer, but for member functions's it's different. You can't
let a normal function pointer point to a non-static member function, so you
have to use a pointer to member for it.

[flopbucket]

> It's called "member access through a pointer to member" (or some such).

struct foo {
int a;
int b;
};

int main() {
foo f;
int foo::*pmem = &foo::a;
f.*pmem = 42; // same effect as f.a = 42;
pmem = &foo::b;
f.*pmem = 42; // same effect as f.b = 42;
}
OK, makes sense now. I was not familiar with this use before.

Is it .* as in:

struct foo
{
int *bar;
}

int val = foo.*bar;
That should be a syntax error.

Yes, I thought it looked a bit funny when I wrote it. Have been away
from C++ for a while.

As to *why* certain things the way they are, read "Design and Evolution
of C++" by Stroustrup, plenty of things are explained there. I bet you
could also find answers to "why some operators cannot be overloaded" on
the web.

Have a copy of that, but have not read it in several years. Will dig
it out and read through it again.

Thanks for the response.

[Pete Becker]

Rolf Magnus wrote:

This is rarely used with pointers to member variables, because you can also
use a normal pointer,

A pointer to member data points to the data for any object that you
apply it to. An ordinary pointer points to the data member in the object
that you pointed it to. For example,

struct S
{
int a;
};

int S::*mptr = &S::a;

S s1;
s1.*mptr = 3; // assigns to s1.a
S s2;
s2.*mptr = 4; // assigns to s2.a

int *data_ptr = &s1.a;
*data_ptr = 5; // asigns to s1.a
// can't use data_ptr to point to s2.a without reassigning its value:

data_ptr = &s2.a;
*data_ptr = 6; // assigns to s2.a

--

Pete Becker
Roundhouse Consulting, Ltd.

[flopbucket]

>A pointer to member data points to the data for any object that you

apply it to. An ordinary pointer points to the data member in the object
that you pointed it to. For example,

[snip]

Thanks for this, makes sense. After being away from C++ for a while
lots of little details like this have slipped my mind.