Re: Overriding new and delete
On Aug 9, 4:44 pm, MJ_India <mail.mohitj...@gmail.com> wrote:
In my current requirement I want to manage memory of some
modules from a pool. All the memory allocations (standard and
user defined data types) in these modules must fetch memory
from some pool. A memory allocated in 1 module is always freed
in same module and is never freed in any other module.
But I don't know how to override new / delete operator.
1) If I override the definition globally, it overrides the
allocation and deallocation in modules where I want heap
memory.
2) If I add extra parameters to new and delete [for ex: void
*operator new(size_t count, bool dummy), void delete(void
*where, bool dummy)] and redefine new to new(true) in required
modules.
a) Operator new (and new[]) works fine, but I don't know how
to make the delete work.
b) I don't know if it is standard and would be supported by
all C++ compilers.
It's standard. Theoretically, the steps you may have to take to
replace new and delete may vary; in practice, it's sufficient to
link you versions in before the library.
Replacing global new and delete, or just adding new placement
new and delete (as you're doing) can be tricky. The main
problem is that a delete expression always calls the
non-placement version, do you need to provide the non-placement
version of operator delete. And since this has to work with the
non-placement operator new as well, you have to replace that was
well. And you have to memorize which allocator or memory pool
was used, in order to know which one to use in the delete; the
classical solution for this is to use some sort of hidden
memory for this, e.g.:
union BlockHeader
{
Allocator* allocator ;
MaxAlignType dummyForAlignment ;
} ;
void*
operator new( size_t n )
{
BlockHeader* p = static_cast< BlockHeader* >(
malloc( n + sizeof( BlockHeader ) ) ) ;
if ( p == NULL ) {
throw std::bad_alloc ;
}
p->allocator = NULL ;
return p + 1 ;
}
void*
operator new( size_t n, Allocator& alloc )
{
BlockHeader* p = static_cast< BlockHeader* >(
alloc.allocate( n + sizeof
( BlockHeader ) ) ) ;
if ( p == NULL ) {
throw std::bad_alloc ;
}
p->allocator = &alloc ;
return p + 1 ;
}
void*
operator delete( void* userPtr )
{
BlockHeader* p = static_cast< BlockHeader* >( userPtr ) - 1 ;
if ( p->allocator == NULL ) {
free( p ) ;
} else {
p->allocator->free( p ) ;
}
}
void*
operator delete( void* userPtr, Allocator& alloc )
{
operator delete( userPtr ) ;
}
(The last is only used if a constructor in the new expression
throws an exception.)
In general, I would try to avoid this solution. If your modules
have distinct classes, you could try using class specific
operator new and delete. Otherwise, named functions can be
used, e.g.:
template< typename T >
T*
create( Allocator& alloc )
{
void* p = alloc.allocate( sizeof( T ) ) ;
try {
return ::new ( p ) T ;
} catch ( ... ) {
alloc.free( p ) ;
throw ;
}
}
template< typename T >
void
destruct( Allocator& alloc, T* obj )
{
obj->~T() ;
alloc.free( obj ) ;
}
3) It works fine If I override new/delete in some modules and make
them static. (I tried on Microsoft Visual C++ environment)
But again I don't know if it legal to make new and delete static. (As
they can be either global or defined for a class)
It's not. They must have external linkage.
4) I tried to redefine new/delete in a namespace and use that
namespace where I want new definition. But Compiler either
ignores it (when I use "using namespace memory_mngr") or
prompt a warning telling new/delete must be global (When I
used memory_mngr::new).
The new and delete operators must be defined at global or class
scope. You can't define them in a namespace.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34