🚀 go-pugleaf

In article nta@oznet03.ozemail.com.au, agray@ozemail.com.au (Alan Gray) writes:
>I pose the following problem.
>
>Given a personalised allocator
>
>    class Malloc {
>
>    public:
>
>      Malloc();
>
>      void *allocate(size_t sz);
>      void  deallocate(void *ptr);
>    };
>
>    void *operator new(size_t sz,Malloc *m=0)	<=== this will cause an ambiguity
>    // ------------------------------------------------
>    // here sz == sizeof(class/struct)
>    // ------------------------------------------------
>    {
>      if(m) {
>        return(m->allocate(sz));
>      } else {
>        return(::operator new(sz));		<=== ambiguous call
>      }
>    }


Both the predefined operator new and your placement version can be called
with a single size_t argument. You have to remove the default argument
value, which will give the effect you appear to want.
	void* operator new(size_t sz, Malloc* m)
	{
		if( m ) return m->allocate(sz);
		... otherwise do something about the error
	}
Thus:
	... new T ... // uses predefined operator new
	... new (&allocator) T ... // uses your operator new

>
>do we need to be able to overload as follows
>
>    void operator delete(void *ptr,Malloc *m=0) ... <=== same ambiguity problem
>
> ... The draft standard does not cover this.

It is covered. There is no syntax for getting an overloaded operator delete
via a delete-expression. You can define a "placement delete", but it is
called only if
 - a constructor invoked from a placement-new expression exits via an exception, or
 - you call the operator delete explicitly.
That is:
	T* p ...
	delete p; // never calls a placement delete
	// but you can do this
	p->~T(); // call destructor
	operator delete(p, &allocator);

You can use class-specific operator new and delete in an Allocator base
class, and these will be inherited by any class derived from Allocator.
You can find examples of how to do this in "The C++ Programming
Language", 2nd edition and in other books.
---
Steve Clamage, stephen.clamage@eng.sun.com