memory management 2

class B 
{	
public:
	virtual ~B();	
	void operator delete  (void*, size_t) throw();		
	void operator delete[](void*, size_t) throw();		
	void f(void*, size_t) throw();		
};

class D : public B
{		
public:		
	void operator delete  (void*) throw();		
	void operator delete[](void*) throw();		
};
// Why do B's operators delete have a second parameter, whereas D's do not?
// should provide new() and new[] ().
// Always explicitly declare operator new() and operator delete() as static functions. They are never nonstatic member functions.
// 1.
D* pd1 = new D; 
delete pd1;  

B* pb1 = new D;
delete pb1;

D* pd2 = new D[10];
delete[] pd2;

B* pb2 = new D[10];
delete[] pb2;
// Never treat arrays polymorphically.

// 2.
typedef void (B::*PMF)(void*, size_t); 
PMF p1 = &B::f;  // fine
PMF p2 = &B::operator delete; // error, because static function.

// 3.
class X 
{
public:
	void* operator new( size_t s, int ) throw( bad_alloc )
	{
		return ::operator new( s );
	}
}; // this invites a memory leak. because it lost operator delete.


class SharedMemory
{
public:
	static void* Allocate( size_t s )
	{
		return OsSpecificSharedMemAllocation( s );
	}
	
	static void  Deallocate( void* p, int i = 0 )
	{
		OsSpecificSharedMemDeallocation( p, i );
    }
	
};

class Y
{		
public:		
   void* operator new( size_t s,SharedMemory& m ) throw( bad_alloc )			
    {		
		return m.Allocate( s );		
    }

    void  operator delete( void* p,	SharedMemory& m, int i ) throw()	
    {	
		m.Deallocate( p, i );	
    }	//This Y::operator delete() is useless because it can never be called.
	
};
// think about the flowing.
SharedMemory shared; 
...
new (shared) Y; // if Y::Y() throws, memory is leaked


// the replacement global operator delete() is going to delete memory allocated normally by the default ::operator new(), 
// not by SharedMemory::Allocate().
void operator delete( void* p ) throw()
{	
    SharedMemory::Deallocate( p );	
}

void operator delete( void* p,std::nothrow_t& ) throw()					 					 
{		
    SharedMemory::Deallocate( p );		
}