Re: pointer to a member of a member

From:

huili80@gmail.com

Newsgroups:

comp.lang.c++

Date:

Fri, 27 Jun 2008 13:12:37 -0700 (PDT)

Message-ID:

<35f101fb-b39a-4aba-bb63-a96abd983e93@a70g2000hsh.googlegroups.com>

On Jun 27, 4:04 pm, Victor Bazarov <v.Abaza...@comAcast.net> wrote:

huil...@gmail.com wrote:

On Jun 27, 3:33 pm, huil...@gmail.com wrote:

On Jun 27, 3:00 pm, Victor Bazarov <v.Abaza...@comAcast.net> wrote:

Greg Herlihy wrote:

On Jun 27, 10:42 am, Victor Bazarov <v.Abaza...@comAcast.net> wrote:

huil...@gmail.com wrote:

Say I have two classes:
class A
{
public:
int x;
};
class B
{
public:
A a;
};
Then how do I construct a member pointer to B::a.x ? What's the sy=

ntax

for it?

Why do you think you need it? Does this help:
B b;
int *ptr = &b.a.x;

The question seems to me to be asking for a member pointer - not a
pointer to a (data) member. If that is the case, then the answer wou=

be that it is not possible to create a single, member pointer to
b.a.x. Instead it is necessary to declare two member pointers (one f=

B::a and the other for A::x) and then apply them both. For example:
    struct A
    {
        int x;
    };
    struct B
    {
        A a;
    };
    int main()
    {
        B b;
        A B::*pa = &B::a;
        int A::*pi = &A::x;
        b.*pa.*pi = 3; // assigns 3 to b.a.x
    }
Greg

I would like to see what the OP has to say about his/her need to crea=

such a construct.
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

Here is an example (probably over-simplified from the actual case I'm
working on). Say I have a 2D vector class:

struct vector2d
{
    double x,y;
    static double vector2d::* const _v[2];
    double& operator[] (int i) { return this->*_v[i]; }
    const double& operator[] (int i) const { return this->*_v[i]; =

}};

double vector2d::* const vector2d::_v[] = { &vector2d::x,
&vector2d::y };

and suppose we have an object "vector2d v;" . The purpose of using
pointer to member here is to make v[0] and v.x have exactly the same
run-time efficiency, provided that the compiler is capable of
necessary optimization. (I didn't invent this technique, but I forgot
where I learned it).

Suppose now for some reason, I want to build a 5D vector class out of
this 2D vector class, say like this.

class vector5d
{
vector2d v1, v2;
double z;

};

and we have an object "vector5d w;"

What I want is, with as little run-time overhead as possible (maybe
using a similar method that's used by vector2d), that w[0] gives me
w.v1.x , w[1] gives w.v1.y , w[2] gives w.v2.x , w[3] gives w.v2.y ,
and w[4] gives me w.z .

Is it possible? If yes, how?

I mean, is it possible to achieve zero run-time overhead (assuming
proper optimization) in accessing members (and their members) via an
index? If we don't have a vector5d::z (in which case it's actually a
4D vector), we might want to use an array of pointers to member of a
member (I don't know how even if they do exist). Having vector5d::z
makes this even more complicated in that a pointer to vector5d::z and
a (may or may not existing) pointer to vector5d::v1.x certainly would
have different types, so they cannot be put into an array.

Thanks!

What you seem to be looking for is

     struct vector5d
     {
         vector2d v1, v2;
         double z;
         double& operator[](int i) {
             switch (i) {
                 case 0: return v1[0];
                 case 1: return v1[1];
                 case 2: return v2[0];
                 case 3: return v2[1];
                 case 4: return z;
                 default: throw "bad index";
             }
         }
     };

Isn't it?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

That gives the correct result, but not the best performance. A more
efficient solution would be

switch(i/2)
{
   case 0: return v1[i%2]; break;
   case 1: return v2[i%2]; break;
   case 2: return z; break;
   default: throw "bad index";
}

because v1[k] (as implemented in my earlier post) is much faster than

if ( k == 0 )
   return v1.x;
else
   return v1.y;

But can we achieve even better efficiency? Directing the program to
different branch based on the even- or odd-ness of an integer would
almost certainly be slower than just shifting a pointer by that
integer. That's exactly how in the vector2d class, v[0] has the same
efficiency as v.x . (again assuming proper optimization).