Re: sup****ting header-less blocks in memory allocators...

Dmitriy V'jukov a écrit :
> On Oct 2, 10:50 pm, "Chris M. Thomasson" <n...@[EMAIL PROTECTED]
> wrote:
> 
>> Please correct me if I am wrong, but it seems as if this particular
>> allocator interface would "need" to know what type it was dealing with
in
>> advance; correct?
> 
> Yes,
> 
>> In other words, it probably could not be used to overload
>> global operator new/delete right?
> 
> Yes.
> 
>> Or, is `derived_t' dealing with internal
>> allocator structures. Where am I going wrong here Dmitriy? You know, I
was
>> thinking about creating something special for C++. But, I am a C
programmer,
>> and felt the need to sup****t my language of choice. The cool thing
about C++
>> is that you can do exactly what you did. Also, you can overload class
local
>> delete operator and have it automatically return the size of the
dynamic
>> allocation be it single object or array. If the user allocated an
array, you
>> simply divide this size of object size, and bam you have array size.
> 
> It's not always true. For example:
> 
> template<typename derived_t>
> struct object_t
> {
>   static void* operator new (size_t sz)
>   {
>     return malloc(sizeof(derived_t));
>   }
> };
> 
> struct derived1 : object_t<derived1>
> {
>   int x1;
> };
> 
> struct derived2 : derived1
> {
>   int x2;
> };
> 
> derived2* d2 = new derived2 (); // CRASH! Allocate memory only for
> derived1, derived2 will not fit into that memory

But if you use the 'sz' parameter of operator new to call malloc(),
then you will allocate enough memory for derived2.
And you can overload the class-local delete operator with a second
size_t parameter, you will known the size of the object to deallocate:

#include <stdlib.h>
#include <stdio.h>

void* alloc_8()  { printf( "alloc_8\n")  ; return malloc( 8 ) ; }
void* alloc_16() { printf( "alloc_16\n") ; return malloc( 16 ) ; }
void free_8( void* ptr )  { printf( "free_8\n" );  ::free( ptr ) ; }
void free_16( void* ptr ) { printf( "free_16\n" ); ::free( ptr ) ; }

template<typename derived_t>
struct object_t
{
     // derived_t is not required to be most derived type

     static void* operator new ( size_t sz )
     {
         // resolution at runtime
         if ( sz <= 8 )
             return alloc_8() ;
         else if ( sz <= 16 )
             return alloc_16() ;
         else
             return ::malloc( sz ) ;
     }

     static void operator delete ( void* ptr, size_t sz )
     {
         // resolution at runtime
         if ( sz <= 8 )
             return free_8( ptr ) ;
         else if ( sz <= 16 )
             return free_16( ptr ) ;
         else
             ::free( ptr ) ;
     }
} ;

struct A  : object_t< A >
{
     virtual ~A() {}
     long x ;
} ;

struct B : A
{
     long y ;
} ;

int main()
{
     printf( "sizeof(A)=%lu\n", sizeof( A ) ) ;
     A* a = new A ;
     delete a ;

     printf( "sizeof(B)=%lu\n", sizeof( B ) ) ;
     B* b = new B ;
     delete b ;
}