«

On Jun 27, 9:09*pm, Andrey Tarasevich <andreytarasev...@hotmail.com>
wrote:
> huil...@gmail.com wrote:
>
> > I was trying to get an answer on how to get a "pointer to a member of
> > a member" if there exists something like that.
> > Maybe such a thing can be used in a good way, who knows.
>
> Of course, it can be. There's no real technical or conceptual difference
> between 'pointer-to-data-member' and
> 'pointer-to-data-member-of-data-member'. They would be used in exactly
> the same way.
>
> Technically, the implementation of such a pointer would be exactly the
> same as that of the existing 'pointer-to-data-member', meaning that the
> pointer _type_ itself is already in the language. The only thing that's
> really missing is the syntax that would let us to assign the proper
> value to such a pointer.
>
> Because of that latter part, the answer is no, you can't use such a
> pointer in standard C++.
>
> --
> Best regards,
> Andrey Tarasevich

So since the pointer type is already in the language, but we just
can't assign a value to it, how can i explicitly get the type of the
pointer? (I just can't figure it out how...) Say what should we use to
replace the ... in the following so that ptr_type is a pointer to
B::a.x ?

class A { public: int x; };
class B { public: A a; };

typedef ... ptr_type;

On Jun 27, 12:45*pm, huil...@gmail.com wrote:
>
> 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.

If you really want to go ahead with a scheme to access class members
via an index, then I would suggest an implementation that takes the
opposite tack: that is, instead of accessing data members as if they
were elements of an array - access the elements of an array as if they
were individual data members.

Specifically, the vector classes could declare an array of doubles as
a member - and then declare various accessor methods that would return
the appropriate element from this array as the value of the
corresponding "virtual" data member. For example

class Vector2D
{
public:
Vector2D( x = 0.0, y = 0.0)
{
d_[0] = x;
d_[1] = y;
}

// operator[n] just returns d_[n]

double& operator[](int n)
{
assert(n >= and n <= sizeof(d_)/sizeof(d_[0]));

return d_[n];
}

// various methods for the "virtual" data members

double& x() { return d_[0]; }
const double& x() const { return d_[0]; }

double& x() { return d_[1]; }
const double& x() const { return d_[1]; }

private:
double d_[2];
};

class Vector3D
{
public:
Vector3D() : d_() {}

double& operator[](int n)
{
assert(n >= and n <= sizeof(d_)/sizeof(d_[0]));

return d_[n];
}

// Vector3D returns the v1 Vector2d "member" only on demand..

Vector2D v1() const { return Vector2D( d_[0], d_[1]); }

double v1_x() { return Vector2D( d_[0]; }
double v1_y() { return Vector2D( d_[1]); }

// declare v2 accessors here

double& z() { return d_[4]; }

private:
double[5] d_;
};

Greg

On Jun 28, 12:32 am, Frank Birbacher <bloodymir.c...@gmx.net> wrote:

[...]
> Are you aware of the fact that the "switch" statement is
> supposed to be optimized by table lookup.

Not really. The switch statement (like everything else in the
basic languaage) is supposed to be optimized in the most
effective way possible on the given platform. For many
platforms, this does mean a table of pointers to code if the
switch is "dense". There are machines, however, on which an
indirect jump is exceedingly expensive, and the sequence of if's
is actually faster, even for dense tables. (Remember, the
compiler will know all of the values, and will generated a
binary search with the if's, so you have at most O(ln n)
comparisons.)

The real point is that the compiler knows the architecture for
which it is generating code, and will use whatever technique is
optimal for that architecture. Trying to second guess it can
never improve performance.

[...]
> This optimization is why a switch will only accept integral values.

Integral *constant* values.

--
James Kanze (GABI Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

On Jun 27, 7:47 pm, 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 syntax
> for it?
> Thanks!

Here is my solution to your problem :

I declare a data member in the B class : the void pointer p,
and I initialize it with the help of the constructor of the B
class.

Hope you are happy with this solution.

-------------------------------------------------------------
class A
{
public:
int x;
};

class B
{
public:
A a;
void *p;
B()
{
B: = &(B::a.x);
};
};

int main()
{

return 0;
}

On Jun 28, 8:07*am, alexandrug <webaig...@gmail.com> wrote:
> On Jun 27, 7:47 pm, 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 syntax
> > for it?
> > Thanks!
>
> Here is my solution to your problem :
>
> I declare a data member in the B class : the void pointer p,
> and I initialize it with the help of the constructor of the B
> class.
>
> Hope you are happy with this solution.
>
> -------------------------------------------------------------
> class A
> * * {
> * * public:
> * * * * int x;
> * * };
>
> class B
> * * {
> * * public:
> * * * * A a;
> * * * * void *p;
> * * * * B()
> * * * * {
> * * * * B: = &(B::a.x);
> * * * * };
> * * };
>
> int main()
> * * {
>
> * * return 0;
> * * }

I'm very happy with the solution. Thank you!
But what if I don't want to increase the size of B?

On Jun 28, 4:45 pm, huil...@gmail.com wrote:
> On Jun 28, 8:07 am, alexandrug <webaig...@gmail.com> wrote:
>
>
>
> > On Jun 27, 7:47 pm, 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 syntax
> > > for it?
> > > Thanks!
>
> > Here is my solution to your problem :
>
> > I declare a data member in the B class : the void pointer p,
> > and I initialize it with the help of the constructor of the B
> > class.
>
> > Hope you are happy with this solution.
>
> > -------------------------------------------------------------
> > class A
> > {
> > public:
> > int x;
> > };
>
> > class B
> > {
> > public:
> > A a;
> > void *p;
> > B()
> > {
> > B: = &(B::a.x);
> > };
> > };
>
> > int main()
> > {
>
> > return 0;
> > }
>
> I'm very happy with the solution. Thank you!
> But what if I don't want to increase the size of B?

Then the pointer would not be a member of the class B.

On Jun 28, 11:50*am, Andrey Tarasevich <andreytarasev...@hotmail.com>
wrote:
> alexandrug wrote:
> --
> Best regards,
> Andrey Tarasevich

I wonder if there is a plan to add this "lost" feature in future
standards of c++?
(or maybe i should ask in comp.std.c++ ? )

On Jun 28, 6:50 pm, Andrey Tarasevich <andreytarasev...@hotmail.com>
wrote:
> alexandrug wrote:
> >> I'm very happy with the solution. Thank you!
> >> But what if I don't want to increase the size of B?
>
> > Then the pointer would not be a member of the class B.
>
> Not a member? How?
>
> Let me illustrate a couple of things by an example. The purpose of
> pointer-to-member types is to facilitate nameless selection of class
> members (as opposed to named selection we usually use).
>
> For example, consider this code sample
>
> struct A { int a; }
>
> struct B {
> int x;
> int y;
> A a;
> int z[10];
> };
>
> void zero(B* b, unsigned n, int B::*m) {
> for (; n > 0; --n, ++b)
> b->*m = 0;
> }
>
> Now, I can use the above simple 'zero' function I can set to zero any
> immediate member of all 'B' objects in an array
>
> B b[10];
>
> zero(b, 10, &B:); // sets all 'B:'s to zero
> zero(b, 10, &B::y); // sets all 'B::y's to zero
>
> Or I can choose what to zero based on some run-time criteria
>
> zero(b, 10, rand() % 2 == 0 ? &B: : &B::y);
>
> This is the valuable run-time flexibility provided by pointers of
> pointer-to-member type (in this case applied specifically to data members).
>
> However, what if I want to zero 'B::a.x' members in the 'b' array? Or
> what about zeroing 'B::z[5]' in each element of the 'b' array? In C++
> you can't do that. And the truth is that from the implementation point
> of view the above pointer type ('int B::*m') is already capable of
> holding the required value (to point to either 'B::a.x' or 'B::z[5]'),
> but the language simply has no syntax to assign that value to that
> pointer. (It can be done with a hack though).
>
> Your solution with a regular pointer inside 'B' will "work", but suffers
> from a number of problems that essentially defeat the purpose in general
> case. If it is good enough for the OPs specific case - great. But how
> are you going to do it without placing anything into 'B'?
>
> --
> Best regards,
> Andrey Tarasevich

-------------------

Then how do I construct a member pointer to B::a.x ? What's the syntax
for it?

-------------------

From the initial post, I understood that a member pointer is a data
member of a class,
not a pointer to a member of a class or to anything else. So take my
postings as such.

Alex.

Alf P. Steinbach wrote:
> * Victor Bazarov:
>> wrote:
>>> On Jun 28, 11:50 am, Andrey Tarasevich
>>> <andreytarasev...@hotmail.com> wrote:
>>>> alexandrug wrote:
>>>> --
>>>> Best regards,
>>>> Andrey Tarasevich
>>> I wonder if there is a plan to add this "lost" feature in future
>>> standards of c++?
>>> (or maybe i should ask in comp.std.c++ ? )
>>
>> Ask here or in comp.lang.c++.moderated. c.s.c++ is unfortunately
>> dead for the time being (multiple inquiries about the reasons have
>> gone unanswered).
>
> Not quite unanswered.
>
> I forwarded an inquiry in comp.lang.c++.moderated about this to two
> of the comp.std.c++ moderators, namely the two that last seemed to
> be active, and the same day (I think it must be related...) Fergus
> replied to that article, as follows:
>
> <url:
> http://groups.google.com/group/comp.lang.c++.moderated/msg/52a26fec00939fe5>:
>
> * Fergus Henderson (comp.std.c++ moderator), on Jun 18 2008:
>> On Jun 11, 10:39 pm, Joe Gottman <jgott...@carolina.rr.com> wrote:
>>
>>> It's now been six months sincecomp.std.c++went down.
>>> According to Google Groups the last post was on January 9th. Does
>>> anybody have any information on when it might come back, or
>>> even exactly what went wrong?
>>
>> The moderation software for comp.std.c++ was hosted on my account
>> on a machine at the University of Melbourne. The university
>> removed my account, and I have not found time
>> to do anything about it. My sincere apologies to all of the users
>> of comp.std.c++.
>>
>> My life circumstances have changed quite a bit in the years since I
>> first volunteered to
>> run the comp.std.c++ moderation software. Back then I was a
>> postgrad student with lots of time. Since then, I now have a few
>> more committments... a job, a wife, a daughter.
>>
>> If someone else wanted to take on the role, I would be quite happy
>> to relinquish it.
>
>
> So, any takers?
>
> It needs some stable company or organization such as a university
> that can host the server, one that will most likely continue to
> exist for many many years. I don't understand why they haven't
> asked Google to do that. But then, I don't know much more than
> anyone else about what happened, or didn't
> happen.

We can only guess that there must be some very special requirements
for that account, as nobody else has been able to take over the
hosting for six months. Google is a good idea, or MS, or IBM, or
Intel, or HP, or Adobe, or Apple - just to mention a few of the
companies involved.

Can't be lack of hardware, can it? I have a spare PC, if it is...


Bo Persson

Hi!

Andrey Tarasevich schrieb:
> For example, consider this code sample
>
> struct A { int a; }
>
> struct B {
> int x;
> int y;
> A a;
> int z[10];
> };
>
> void zero(B* b, unsigned n, int B::*m) {
> for (; n > 0; --n, ++b)
> b->*m = 0;
> }
>
> Now, I can use the above simple 'zero' function I can set to zero any
> immediate member of all 'B' objects in an array
>
> B b[10];
>
> zero(b, 10, &B:); // sets all 'B:'s to zero
> zero(b, 10, &B::y); // sets all 'B::y's to zero

typedef int& (*BIntMember) (B*);

void zero(B*const b, unsigned const n, BIntMember const m) {
for(; n>0; --n, ++b)
m(b) = 0;
}

int& B_x(B*const b) { return b->x; }
int& B_y(B*const b) { return b->y; }
int& B_a_a(B*const b) { return b->a.a; }

B b[10];

zero(b, 10, &B_x);
zero(b, 10, &B_y);
zero(b, 10, &B_a_a);

OR using boost.lambda:

for_each(b, b+10, bind(&B_x, _1) = 0);
for_each(b, b+10, bind(&B_x, _1)++);
....

Frank