Re: outer class `this` in local classes without inheritance?
On 27 Jul., 06:30, Lorenzo Caminiti <lorcamin...@gmail.com> wrote:
I am new to this groups. I would like to post a C++ programming
question.
You are welcome to do so!
Is there a way to access the outer class `this` from a local class
but without using inheritance?
Let me explain with an example:
class x { // outer class
public:
void g() {}
void f() {
this->g(); // (1)
struct y: x { // local class but using inheritance...
y(x* super): x(*super) {} // (2)
void h() {
this->g(); // (3)
}
};
y(this).h();
}
};
*** Is there a way to do this but without inheriting `y` from `x`? ***
Yes, but that requires that y has a constructor accepting
a (reference or pointer to) x and has a member of pointer or
reference type, e.g. like this:
class x { // outer class
public:
void g() {}
void f() {
this->g(); // (1)
struct y { // local class, no inheritance
x* that; // References an object of the outer class
y(x* super): that(super) {} // (2)
void h() {
that->g(); // (3)
}
};
y(this).h();
}
};
Question: Do you have Java background, where it is possible to
define a "non-static" inner class with implied constructor argument
for an object of the outer class?
At line (3), the local class `y` can access the outer class `x::g()`
simply using `this` because `y` inherits from `x`. However, this
inheritance requires to construct another object `x` when `y` is
constructed as in line (2) adding runtime overhead and requiring `x`
to have an accessible copy constructor.
Yes, and this idiom is not required.
In my application, I need line (3) to essentially look the same as
like line (1) so you can program code inside `y` members as if it were
inside `x` members. A part from that, the local class `y` could look
as it is needed to solve this problem -- with more member variables,
member functions, etc.
But note that there are some restrictions to local classes, among
them it is not feasible to have static data members.
(For example, I tried to redefine `y::operator->()`/`y::operator*()`
to return a pointer/reference to `x` but this does not work because
`this->`/`*this` always retain pointer semantics and do not use the
operators I redefined...)
This should also work, you can simply define:
x* operator->() const { return that; }
as inline function in y. It is not possible to define any member
functions outside of the local class, though.
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]