Is this like calling a virtual function at construction time?

Hello!

I frequently read that at construction time "*this" has the type of the
class being constructed at the moment. This is usually written in
conjunction with calling virtual functions from constructors.

My case seams similar to the above but is not exactly the same. The
following code depicts my case (sort of, but the C++ mechanics
involved are the same).

#include <iostream> // for std::cout

class IPure
{
public:
     virtual void Work() = 0;
     virtual ~IPure() {} // empty
};

class Base : public IPure
{
private:
     IPure *next;
public:
     Base() : next(this) {} // empty
     void CallNextWork() { next->Work(); }
     virtual void Work() { std::cout << "Base"; }
};

class Derived : public Base
{
public:
     virtual void Work() { std::cout << "Derived"; }
};

int main()
{
     Base *base = new Derived();

     base->CallNextWork();
     delete base;
     return 0;
}

In the above code, I want Derived::Work to be called. And so it happens
with two compilers I've tested it.

But I wonder. Since Base::next is initialized at "Base"s
construction time, when its type is "Base", why is it that it works
the way I want?

Can I rely on this behavior? What does the C++ standard say about this?

Thanks in advance.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]