is this possible?

[Kev]

Hi, lets see if I can explain this right. :o)

Lets say I wish to change several variables nested multiple classes deep.
The usual way I figure is to just say "class#.struct. a (b,c...) =
somenumbers;". Is there a way to preset "class#' at the beginning of the
function its passed to so that I can just say 'struct.a (b,c) = numbers'
and "class#' is assumed?

cheers

[David White]

"Kev" <di************ **@pht.zzz> wrote in message
news:Xn******** **************@ 216.168.3.44...

Hi, lets see if I can explain this right. :o)

Lets say I wish to change several variables nested multiple classes deep.
The usual way I figure is to just say "class#.struct. a (b,c...) =
somenumbers;".
I'm assuming you really mean multiple _objects_ deep.
Is there a way to preset "class#' at the beginning of the
function its passed to so that I can just say 'struct.a (b,c) = numbers'
and "class#' is assumed?

Only if the function is a non-static member function of the class of which
the object class# is an instance.

DW

[John Carson]

"Kev" <di************ **@pht.zzz> wrote in message
news:Xn******** **************@ 216.168.3.44

Hi, lets see if I can explain this right. :o)

Lets say I wish to change several variables nested multiple classes
deep. The usual way I figure is to just say "class#.struct. a (b,c...)
= somenumbers;". Is there a way to preset "class#' at the beginning
of the function its passed to so that I can just say 'struct.a (b,c)
= numbers' and "class#' is assumed?

cheers

Given an outer object (or a reference or pointer to it), you can create a
reference (or pointer) to an inner object, e.g.,
struct Outer
{
struct Inner
{
struct DoubleInner
{
int a, b, c;
};
DoubleInner doubleinner;
};
Inner inner;
};

void Setabc(Outer &o)
{
Outer::Inner::D oubleInner & shortcut = o.inner.doublei nner;
shortcut.a = 1;
shortcut.b = 2;
shortcut.c = 3;
}

The other way to do it is to make Setabc take a reference to DoubleInner as
its argument:

void Setabc(Outer::I nner::DoubleInn er &di)
{
di.a = 1;
di.b = 2;
di.c = 3;
}

You would then have to supply, say, o.inner.doublei nner as an argument to
the function.

--
John Carson

[Gernot Frisch]

"Kev" <di************ **@pht.zzz> schrieb im Newsbeitrag
news:Xn******** **************@ 216.168.3.44...

Hi, lets see if I can explain this right. :o)

Lets say I wish to change several variables nested multiple classes
deep.
The usual way I figure is to just say "class#.struct. a (b,c...) =
somenumbers;". Is there a way to preset "class#' at the beginning of
the
function its passed to so that I can just say 'struct.a (b,c) =
numbers'
and "class#' is assumed?

class A
{
public:
int m;
};
class B
{
public:
double m;
}
template <class C> changeM(C* pC)
{
pC->m = 0;
}

int main()
{
A a; B b;
changeM(&a);
changeM(&b);
}

Is this what you want??

[Kev]

"John Carson" <jc************ ****@netspace.n et.au> wrote in news:daii34
$1*****@otis.ne tspace.net.au:

void Setabc(Outer &o)
{
Outer::Inner::D oubleInner & shortcut = o.inner.doublei nner;
shortcut.a = 1;
shortcut.b = 2;
shortcut.c = 3;
}

Would this work if Outer could represent more than one classtype, but
sharing the same base? Perhaps using the base classname instead? Similar to
using a base pointer for a derived class? In this case DoubleInner would be
in the base, common to all.

Base::Inner::Do ubleInner &shortcut ?

[John Carson]

"Kev" <di************ **@pht.zzz> wrote in message
news:Xn******** **************@ 216.168.3.44

"John Carson" <jc************ ****@netspace.n et.au> wrote in
news:daii34 $1*****@otis.ne tspace.net.au:

void Setabc(Outer &o)
{
Outer::Inner::D oubleInner & shortcut = o.inner.doublei nner;
shortcut.a = 1;
shortcut.b = 2;
shortcut.c = 3;
}

Would this work if Outer could represent more than one classtype, but
sharing the same base? Perhaps using the base classname instead?
Similar to using a base pointer for a derived class? In this case
DoubleInner would be in the base, common to all.

Do you mean the class DoubleInner or the variable doubleinner or both? If
Outer is a base class, say:

struct Derived1 : public Outer
{
// stuff
};

struct Derived2 : public Outer
{
// stuff
}

and we have an instance of a derived class:

Derived1 d1;

then we can call the original function with no change:

Setabc(d1);

All the action is in the base class and the fact that it is derived from is
irrelevant.

The more general point is this: if you can get access to member variables
within the function via a series of objects/pointers:

a.b->c.d.e->f.g.member1
a.b->c.d.e->f.g.member2
a.b->c.d.e->f.g.member3

then you can produce a shortcut with which to access members 1-3 as follows:

A::B::C::D::E:: F::G & shortcut = a.b->c.d.e->f.g;

where A is the type of a, B* is the type of b, C is the type of c and so on.

You then call it with

shortcut.member 1
shortcut.member 2
shortcut.member 3

If the last thing in the original chain before the members is a pointer
rather than an object, i.e.,

a.b->c.d.e->f.g->member1
a.b->c.d.e->f.g->member2
a.b->c.d.e->f.g->member3

then the definition of shortcut changes via the addition of an asterisk so
that it becomes a reference to a pointer:

A::B::C::D::E:: F::G *& shortcut = a.b->c.d.e->f.g;

(note that pointers earlier in the chain affect the right-hand side of the
assignment, but not the left-hand side; by contrast, if the final thing in
the chain is a pointer, it affects the left-hand side but not the right-hand
side). You use shortcut as follows:

shortcut->member1
shortcut->member2
shortcut->member3

You can also transform a pointer into a reference or a reference into a
pointer. This is left as an exercise for the reader.

--
John Carson

[Kev]

"John Carson" <jc************ ****@netspace.n et.au> wrote in news:dal1e5
$2*****@otis.ne tspace.net.au:

A::B::C::D::E:: F::G & shortcut = a.b->c.d.e->f.g;

I get compiler errors with A::B saying that B is not a member of A. So...
Im sure Im making some 'bite me in the ass' mistake someplace that I will
find ;o)

I appreciate everyones efforts and sharing different ways to figure this
out. After reading further using 'namespace' in some more elaborate ways
might offer something. But I might have misunderstood and need to read
further.

cheers all!!!

[John Carson]

"Kev" <di************ **@pht.zzz> wrote in message
news:Xn******** *************@2 16.168.3.44

"John Carson" <jc************ ****@netspace.n et.au> wrote in
news:dal1e5 $2*****@otis.ne tspace.net.au:

A::B::C::D::E:: F::G & shortcut = a.b->c.d.e->f.g;

I get compiler errors with A::B saying that B is not a member of A.
So... Im sure Im making some 'bite me in the ass' mistake someplace
that I will find ;o)

My description assumes that B is a class/struct nested inside A, that C is a
class/struct nested inside B and so on. Taking a two struct case for
simpliciy, if, say, you had this scenario:

struct B
{
int member1, member2;
};

struct A
{
B b;
};

Then clearly given

A a;

a.b gives you an object of B, not an object of A::B. Thus you would use:

B & shortcut = a.b;

shortcut.member 1
shortcut.member 2

Basically, given

a.b->c.d.e->f.g.member1

you have to figure out the type of g. You then declare:

Type_of_g & shortcut = a.b->c.d.e->f.g;
--
John Carson

[Kev]

"John Carson" <jc************ ****@netspace.n et.au> wrote in news:dalc5p
$2*****@otis.ne tspace.net.au:

you have to figure out the type of g. You then declare:

Type_of_g & shortcut = a.b->c.d.e->f.g;

Apologies, was away for awhile. After thinking about the problem I really
was making it more difficult than I needed to. Many things just werent in
the right place to begin with. The shortcut ideas are less complicated,
done a little differently, and work nicely.

Thank you :o)

Theres another puzzler about stl::list, and also something Im going about
the wrong way Im sure. But thats another post :o)