"Dmitriy V'jukov" <dvyukov@[EMAIL PROTECTED]
> wrote in message
news:aabd7f24-429e-4276-bbcc-790bbc4959b2@[EMAIL PROTECTED]
> 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:
[...]
Check this program out:
_____________________________________________________________________
#include <cstdio>
#include <cstdlib>
#include <new>
struct custom_allocator {
static void* allocate(std::size_t size)
throw(std::bad_alloc()) {
void* const mem = ::operator new(size);
std::printf("custom_allocator::allocate(%p, %lu)\n",
(void*)mem, (unsigned long)size);
return mem;
}
static void deallocate(void* const mem, std::size_t size)
throw() {
std::printf("custom_allocator::deallocate(%p, %lu)\n",
(void*)mem, (unsigned long)size);
::operator delete(mem);
}
};
template<typename T>
struct allocator_base {
static void* operator new(std::size_t size)
throw(std::bad_alloc()) {
return custom_allocator::allocate(size);
}
static void* operator new[](std::size_t size)
throw(std::bad_alloc()) {
return custom_allocator::allocate(size);
}
static void operator delete(void* mem)
throw() {
if (mem) {
custom_allocator::deallocate(mem, sizeof(T));
}
}
static void operator delete [](void* mem, std::size_t size)
throw() {
if (mem) {
custom_allocator::deallocate(mem, size);
}
}
};
template<std::size_t T_size>
class buf : public allocator_base<buf<T_size> > {
char mem[T_size];
};
class buf2 : public buf<1234> {
char mem2[1000];
};
int main() {
buf2* b = new buf2;
delete b;
b = new buf2[5];
delete [] b;
return 0;
}
_____________________________________________________________________
Well, on GCC, it seems to calculate correct sizes... Alls I would need to
hard core optimizations would be the size on delete... Humm... What say
you?
|
