On Jul 27, 10:43 am, Goran Pusic <gor...@cse-semaphore.com> wrote:
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.
The thing is, like with many newbie questions, you think that you need
line (3). But in fact, there's probably much more ways to achieve
desired end result, overall (calling g() on an instance of x is just
part of that result). In other words, you should consider changing
your question so that it tells more about what you want to do. The
question you asked is "can I do __this__ so that I can do __that__?".
But __this__ is tangential (and trivial).
I want to program code inside `y` members as if it were inside `x`
members. This is my only requirement.
Here's more background information about what I want to do and why.
BACKGROUND
I am programming a macro which evaluates a code expression in constant-
correct context by executing the code from within a local function by
passing the object `this` and other variables as `const`. For example,
the `BLOCK_INVARIANT()` macro can be programmed so that the following:
class c {
public:
c(int x): x_(x) {}
bool eq(int x) const { return x_ == x; };
void f(int x) {
BLOCK_INVARIANT( (const (c*)(this) (int)(x) (this_->eq(x)
== false)) )
}
private:
int x_;
};
Expands to:
class c {
public:
c(int x): x_(x) {}
bool eq(int x) const { return x_ == x; };
void f(int x) {
struct block_invariant {
static void check(c const* const this_, int const& x)
{
if(!( this_->eq(x) == false )) { // Evaluated in
constant-correct context because `this_` and `x` are `const`.
throw int(-1);
}
}
};
block_invariant::check(this, x);
}
private:
int x_;
};
Now the compiler will generate an error if the code expression passed
to `BLOCK_INVARIANT()` -- `this_->eq(x)` in this example -- is not
constant-correct.
However, ideally the code expression passed to `BLOCK_INVARIANT()`
will looks the exactly the same as the code programmed within `f()`.
Therefore, `this_->eq(x)` will ideally be `this->eq(x)`. Is there a
way I can do this without inheriting `block_inv` from `c`? And that is
what I need.
REPLIES
For example, thank you for the following suggestions but they do not
work because:
On Jul 27, 10:43 am, Daniel Kr?gler <daniel.krueg...@googlemail.com>
wrote:
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();
}
};
Line (3) does not look the same as line (1). In other words, this
solution does not work because I would use `that` inside `y` members
and `this` inside `x` members so line (1) and (3) look different from
each other.
On Jul 27, 10:44 am, Anthony Williams <anthony....@gmail.com> wrote:
#include <iostream>
class X
{
private:
void g()
{
std::cout<<"g(), this="<<this<<std::endl;
}
public:
void f()
{
std::cout<<"f(), this="<<this<<std::endl;
struct local
{
X* self;
local(X* self_):
self(self_)
{}
void foo()
{
self->g();
}
};
local y(this);
y.foo();
}
};
Similarly, this does not work because `self->g()` from within the
local function looks different from `this->g()` from within the non-
local function.
....
[ comp.lang.c++.moderated. First time posters: Do this! ]