operator new in custom namespace

[dirk]

Why doesn't the standard allow to overload operator new/delete in my
namespace, e.g.

namespace Foo
{
void* operator new( std::size_t sz );
void operator delete( void* address );
}

On the other hand I can overload new/delete per class:

class Foo1
{

static void* operator new( std::size_t sz );
static void operator delete( void* address );

};

And finally what happens if I have classes A and B that overwrite new
and delete and a class C that now inherits from both. What is the
expected behaviour there?

Cheers,
-Dirk

[Victor Bazarov]

di**@dirkgregorius.de wrote:

Why doesn't the standard allow to overload operator new/delete in my
namespace, e.g.

namespace Foo
{
void* operator new( std::size_t sz );
void operator delete( void* address );
}

On the other hand I can overload new/delete per class:

class Foo1
{

static void* operator new( std::size_t sz );
static void operator delete( void* address );

'static' is implicit here, IIUIC. IOW, you don't need to use the
keyword in the function declaration.

>
};

And finally what happens if I have classes A and B that overwrite new
and delete and a class C that now inherits from both. What is the
expected behaviour there?

Not sure what having operator new in its own namespace would do. The
language says that if a class has operator new overloaded, then the
operator is used to allocate memory when constructing a dynamic object
of that class (chosen over the global operator new). What are you
trying to accomplish with the overloaded operator new in a namespace?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[James Kanze]

On Apr 11, 11:04 am, [e-mail] wrote:

Why doesn't the standard allow to overload operator new/delete in my
namespace, e.g.

namespace Foo
{
void* operator new( std::size_t sz );
void operator delete( void* address );
}

Historical reasons, I would imagine.

On the other hand I can overload new/delete per class:

class Foo1
{
static void* operator new( std::size_t sz );
static void operator delete( void* address );
};

And finally what happens if I have classes A and B that overwrite new
and delete and a class C that now inherits from both. What is the
expected behaviour there?

Ambiguous. The compiler should complain.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]