"Paul"<pchristor@yahoo.co.uk> wrote...
"Liviu"<lab2k1@gmail.c0m> wrote...
"Paul"<pchristor@yahoo.co.uk> wrote...
I used the term "belong to" in a different context.
Which is exactly part of the problem - you keep using the term
"belongs to", but repeatedly failed to provide a definition for it.
Except maybe "it's whatever makes the 'function belongs to object'
statement true" ;)
I don't keep using this term,
Of course you do. The whole thread revolves around your insistence that:
|| A member function of an object belongs
|| to the instance of the object it was called on.
Which is but an empty statement without defining what "belongs to" means
to you. Except that you consider the above to be self-evidently true ;-)
I used it to emphasise the point in the example to prove that you
cannot recurse a nsmf with 'this' pointing to different objects per
recursion
'this' does hold the same address during recursion. That's a trivial
consequence of 'this' being a const pointer inside member functions.
What's less clear, though, is how (you think) this relates to the other
"belongs to" part.
And btw, that's not the same as saying that 'this' must point to the
same object all along. Unless of course you use "different objects"
in some other bizarre sense which you didn't care to define.
A nsmf _can_ possibly recurse into objects other than the one it was
originally called on. See P.S. below for an example (and note the
comment in A::f - at that point you are inside a member function which
has no object to "belong to" in any sensible sense I can imagine for
"belongs to").
The static variable is simply shared across function invocations,
nothing magic about it,
I thought you were saying that what's invoked is a "member function
_instance_". Now it's not clear whether you backtrack and say that
what's invoked is _the_ member function, or whether it's still about
different "function instances" which however "share" variables through
some unnamed mechanism.
I hope this clears up any confusion.
Yes, entirely. What I've learnt is that "member function instances" have
the same address, share function-local statics, and in general follow
the same rules as functions at large. Yet, what the C++ standard
meant to say but forgot, is that it's more natural to think of them as
per-object "instances" since... err... whatever ;-)
Anyway, this exercise is getting old and tired. Not to mention futile.
Bye now,
Liviu
P.S. The following is meant to show that a recursive member function
call may land on different objects, and even different types of objects.
Disclaimer: just because it's possible doesn't mean it's advisable ;-)
That said, the code compiles cleanly under Comeau online in strict mode.
A test run on my machine outputs:
A::f, object 1, this = 0012FF54
A::f, object 2, this = 0012FF54
B::f, object 1, this = 0012FF54
B::f, object 2, this = 0012FF54
B::f, object 3, this = 0012FF54
A::f, object 3, this = 0012FF54
A::f, object 4, this = 0012FF54
A::f, object 5, this = 0012FF54
B::f, object 4, this = 0012FF54
B::f, object 5, this = 0012FF54
B::f, object 6, this = 0012FF54
//--------------------------------
#include "iostream"
using std::cout;
using std::endl;
struct A
{
static int count, alive;
A() { count++; alive++; }
~A() { alive--; }
virtual void f(int n);
};
struct B : public A
{
static int count, alive;
B() { count++; alive++; }
~B() { alive--; }
virtual void f(int n);
};
int A::count, A::alive, B::count, B::alive;
void A::f(int n)
{
cout<< "A::f, object "<< count - B::count<< ", this = "<< (const
void *)this<< endl;
if(n)
{
this->~A();
/*
note: right here 'this' points to an unitialized object,
which is legal for essentially the same reasons
why 'delete this' is allowed in member functions
*/
(n % 3) ? new(this) A : new(this) B;
f(n - 1);
}
}
void B::f(int n)
{
cout<< "B::f, object "<< count<< ", this = "<< (const void *)this
<< endl;
if(n)
{
this->~B();
(n % 3) ? new(this) B : new(this) A;
f(n - 1);
}
}
int main()
{
A a;
a.f(10);
}