Re: using nested types for custom allocator of incomplete type
On Jun 19, 12:42 am, Paul Bibbings <paul_bibbi...@googlemail.com>
wrote:
abir wrote:
I have an custom allocator implementation whose base type depends on
completeness of the type parameter T, though the nested types doesn't
depend on so.
e.g.
template<typename T>
struct is_Small
{
const static bool value = (sizeof(T) < sizeof(void*) );
};
template<typename T> struct impl1{};
template<typename T> struct impl2{};
template<typename T>
struct my_alloc : private select<is_small<T> , impl1<T> , impl2<T>
::type
{
typedef T* pointer;
...
};
struct foo; //incomplete type.
typedef my_alloc<foo>::pointer foo_ptr;
The same problem are supposed to happen for stack_alloc<T,N> also, as
usually they has std::aligned_storage as memory.
So far with std::allocator these wasn't a problem though it's allocate
function is usually
return operator new (sizeof(T) *n);
I can pull the traits in a separate class as
template<typename T>
struct alloc_traits
{
typedef. T* pointer ; ...
};
and use it as
typedef alloc_traits<foo>::pointer foo_ptr;
But then I need to change the code everywhere.
Is it possible to design my_alloc such as the nested types which are
independent can still work where rest of functionality depends on
completeness of T ?
Or even is it possible to define some lazy_typedef which don't try to
instantiate the class.
I need the pointers to be defined for incomplete type for any
allocator, as otherwise many cyclic dependency will happen.
The problem, as you have stated it, is that the type(s) that you inherit
my_alloc from require T to be a complete type. You are looking for way=
s to work
around this, no doubt, but have you considered breaking this dependency? =
I am
envisaging something along the lines of:
// file: custom_allocator.cpp
#include <cstdlib>
#include <cstddef>
template<typename T>
struct allocator_traits
{
typedef size_t size_type;
typedef T* pointer;
// ...
};
template<
typename T,
template<typename> class Alloc = allocator_traits
>
struct impl1
{
typedef typename Alloc<T>::size_type size_type;
typedef typename Alloc<T>::pointer pointer;
// ...
static pointer allocate(size_type n) { // or what=
ever
return (pointer) malloc(n * sizeof(T));
}
static void deallocate(void* p) { // d=
itto
if (p) free(p);
}
// ...
};
template<
typename T,
template<typename> class Alloc = allocator_traits
>
struct impl2
{
typedef typename Alloc<T>::size_type size_type;
typedef typename Alloc<T>::pointer pointer;
// ...
static pointer allocate(size_type n) { // or what=
ever
return (pointer) malloc(n * sizeof(T));
}
static void deallocate(void* p) { // d=
itto
if (p) free(p);
}
// ...
};
template<typename T>
struct is_small
{
const static bool value = sizeof(T) < sizeof(void*);
};
template<
bool B,
typename T,
typename T1 = impl1<T>,
typename T2 = impl2<T>
>
struct select
{
typedef T1 type;
};
template<
typename T,
typename T1,
typename T2
>
struct select<false, T, T1, T2>
{
typedef T2 type;
};
template<
typename T,
template<typename> class Alloc = allocator_traits
>
class my_alloc
{
public:
typedef typename Alloc<T>::size_type size_type;
typedef typename Alloc<T>::pointer pointer;
// ...
pointer allocate(size_type n, const void* = 0) {
return select<is_small<T>::value, T>::type::allocate(n=
);
}
void deallocate(void* p, size_type) {
select<is_small<T>::value, T>::type::deallocate(p);
}
// ...
};
struct foo; // incomplete type
typedef my_alloc<foo>::pointer foo_ptr; // OK
struct foo { };
Note that, here, I have not used an allocator_traits type to *solve* your
problem, but merely as a convenience.
Nice. This is nearly what I wanted, though not exactly. Actually impl1
& impl2 contains state, otherwise I could have put all of the
implementations in the same class my_alloc. It seems there is no way
to tackle that apart from having another indirection using a base
class (non polymorphic) for impl1 & impl2 and storing that pointer in
my_alloc. And then using static dispatch.
A similar kind problem with automatically choosing between boost
shared_ptr and intrusive_ptr, given that the two construct has enough
similarity and differences are mostly how ref count is stored, may not
be possible for incomplete types, as accessing any nested typedef for
it instantiates the class.
e.g.
template<typename T>
struct refcount_ptr : select < has_add_ref<T> ,
boost::intrusive_ptr<T> , boost::shared_ptr<T> > {};
struct foo;
typedef refcount_ptr<foo> foo_ptr;
typedef foo_ptr::element_type foo_type; //should be same as foo and
doesn't depend on completeness of foo.
//the line above is problematic in same way. though element_type for
both intrusive_ptr and shared_ptr are allowed when used with
incomplete type.
and then,
struct foo{};
void use()
{
foo_ptr p (new foo());//let it resolve the complete type of foo_ptr
here.
]
I am not seeing any way to suspend the type checking process untill
complete type information is found.
Thanks for looking at the problem and giving a solution.
Regards
abir
Regards
Paul Bibbings