Re: outer class `this` in local classes without inheritance?
On 29 Jul., 02:16, Lorenzo Caminiti <lorcamin...@gmail.com> wrote:
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
Do you mean *const-correct* here?
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`.
OK, you *mean* const-correct ;-)
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.
I can think only of one way to realize that, but it requires
a new feature of C++0x, which are lambda expressions:
A lambda expression produces a class type within the
smallest scope that contains the expression. Without any
macro, the test could be written as follows:
class c {
public:
c(int x): x_(x) {}
bool eq(int x) const { return x_ == x; };
void f(int x) {
// Macro expansion starts here
[&] {
if (!(this->eq(x) == false)) {
throw int(-1);
}
}();
// Macro expansion end here
}
private:
int x_;
};
I'm not sure whether this approach satisfies your const-
correctness stringency. Above code is always well-formed,
if the test-expression were well-formed within the same
context (which is the context of c::f in above example). Since
f() is a non-constant member function, it would also allow
for tests that call non-const functions, because those are
valid in that context.
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! ]