A subtle access issue (may be advanced :-) )

The following code compiles as-is with g++ and Comeau Online, but not when then
the commented lines are uncommented:

<code>
#include <stddef.h>

template< class T > T* create();

class Base
{
template< class T > friend T* create();
private:
     static void* operator new( size_t size )
     {
         return ::operator new( size );
     }

// static void operator delete( void* p )
// {
// ::operator delete( p );
// }

protected:
     virtual ~Base() {}
};

class Derived
     : public Base
{
public:
     Derived() {}
     virtual ~Derived() {}
};

template< class T >
T* create() { return new T; }

int main()
{
     create<Derived>();
}
</code>

With uncommenting the commented code both compilers complain that the Derived
destructor can't access Base::operator delete.

They don't complain that the Derived constructor can't access Base::operator new.

I can understand the lack of complaint for the constructor: the constructor
doesn't need to access the allocation function, which is invoked by the new
expression which is in the context of the create function which has access.

I don't understand the complaint for the destructor. The new expression has to
potentially deallocate, if an expression is thrown. But it manages well to use
the allocation function, so why can't it also use the deallocation function?

In short, why this different treatment?

It almost seems as if the standard supports an implementation technique where
the call to the deallocation function is made directly from *within* the most
derived class' destructor?

Cheers & TIA.,

- Alf