Dave wrote:[color=blue]
> Hello all,
>
> I'd like to find a source on the web that discusses, in a comprehensive
> manner and in one place, everything about new / delete. It should include
> overloading operator new, the new operator, placement, nothrow, arrays,
> etc...
>
> My books cover the topic, I've found FAQs on the web that cover the topic,
> and so on, but all the sources I've found are disjointed. There's a bit on
> this page, a bit on that page, and so on. The information may all be there,
> but it's kind of hard to piece it all together.
>
> If anybody knows of an article out there that gives a comprehensive
> treatment of this topic in one place, I'd appreciate a link.[/color]
I don't know of one but let's see if we can make one !
http://www.google.com/search?q=new+d....parashift.com
That will give you a fairly detailed treatment of the topic.
The code below covers most of the new/delete usages I have used.
------------------------------------------------------------------------
#include <unistd.h>
#include <cstring>
// non-portable but non-allocating write method
void Write( const char * l_str )
{
::write( 1, l_str, std::strlen( l_str ) );
::write( 1, "\n", 1 );
}
#include <new>
#include <cstdlib>
inline void * operator new ( size_t i_val )
{
Write( "new called" );
void * l_ptr = std::malloc( i_val );
return l_ptr;
}
inline void operator delete ( void * i_ptr )
{
Write( "delete called" );
if ( i_ptr )
{
std::free( i_ptr );
}
}
struct A
{
A()
{
Write( "A contructed" );
}
~A()
{
Write( "A destructed" );
}
};
template <typename X>
void test1()
{
X * l_a = new X;
delete l_a;
X * l_b = new X[3];
delete [] l_b;
}
// This does not seem to be called - no matter what
inline void operator delete ( void * i_ptr, size_t i_val )
{
Write( "delete (with size) called" );
if ( i_ptr )
{
std::free( i_ptr );
}
}
template <typename X>
void test2()
{
X * l_a = new X;
delete l_a;
X * l_b = new X[3];
delete [] l_b;
}
struct B
{
inline void * operator new ( size_t i_val )
{
Write( "B::new called" );
void * l_ptr = std::malloc( i_val );
return l_ptr;
}
inline void operator delete ( void * i_ptr )
{
Write( "B::delete (with size) called" );
if ( i_ptr )
{
std::free( i_ptr );
}
}
B()
{
Write( "B contructed" );
}
~B()
{
Write( "B destructed" );
}
};
struct C
{
inline void * operator new ( size_t i_val )
{
Write( "C::new called" );
void * l_ptr = std::malloc( i_val );
return l_ptr;
}
inline void * operator new ( size_t i_val, void * i_ptr )
{
Write( "C::new placement new called" );
return i_ptr;
}
inline void operator delete ( void * i_ptr, size_t i_val )
{
Write( "C::delete (with size) called" );
if ( i_ptr )
{
std::free( i_ptr );
}
}
C()
{
Write( "C contructed" );
}
~C()
{
Write( "C destructed" );
}
};
template <typename X>
void test3()
{
long x[ ( sizeof( long ) + sizeof( X ) -1 )/sizeof( long ) ];
X * l_x = new ( ( void * ) x ) X;
l_x->~X();
}
int main()
{
Write( "\ntest1<A>" );
test1<A>();
Write( "\ntest2<A>" );
test2<A>();
Write( "\ntest1<B>" );
test1<B>();
Write( "\ntest1<C>" );
test1<C>();
Write( "\ntest3<A>" );
test3<A>();
Write( "\ntest3<C>" );
test3<C>();
}
-------- output ----------
../new_del
test1<A>
new called
A contructed
A destructed
delete called
new called
A contructed
A contructed
A contructed
A destructed
A destructed
A destructed
delete called
test2<A>
new called
A contructed
A destructed
delete called
new called
A contructed
A contructed
A contructed
A destructed
A destructed
A destructed
delete called
test1<B>
B::new called
B contructed
B destructed
B::delete (with size) called
new called
B contructed
B contructed
B contructed
B destructed
B destructed
B destructed
delete called
test1<C>
C::new called
C contructed
C destructed
C::delete (with size) called
new called
C contructed
C contructed
C contructed
C destructed
C destructed
C destructed
delete called
test3<A>
A contructed
A destructed
test3<C>
C::new placement new called
C contructed
C destructed
