Re: using nested types for custom allocator of incomplete type
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 ways 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 whatever
return (pointer) malloc(n * sizeof(T));
}
static void deallocate(void* p) { // ditto
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 whatever
return (pointer) malloc(n * sizeof(T));
}
static void deallocate(void* p) { // ditto
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.
Regards
Paul Bibbings