Re: compile time error due to changes in stl_list.h code
On Jul 19, 8:53 pm, fimarn <fim...@gmail.com> wrote:
On Jul 19, 3:42 am, James Kanze <james.ka...@gmail.com> wrote:
fimarn wrote:
I am trying to get rid of compile time error that I am getting
only in RHEL5 (not in RHEL4) apparently due to the changes in
the stl_list.h file. The error that I am getting is coming
from the following code that attempts to remove an item from
the list:
[...]
========================
=
The allocator is declared as :
template<class T>
class SharedMemAlloc {
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T *pointer;
typedef const T *const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef T value_type;
template <class _T> struct rebind {
typedef SharedMemAlloc<_T> other;
};
static pointer allocate(size_type n)
{
return (pointer)SharedMemObj::allocate(n);
}
static void deallocate(void* p, size_type n)
{
SharedMemObj::deallocate(p, n);
}
void construct(pointer p, const T&val) {new (p) T(val); }
void destroy(pointer p) {p->~T(); }
};
You're missing the conversion constructor. In the standard
allocator, it's a:
template< typename U > allocator( allocator< U > const& ) ;
but if I understand the requirements correctly, all that is
required is that:
Allocator< T > a( b ) ;
is legal, where b has a type Allocator< U >, with U different
from T. (So a conversion operator or an explicit constructor
would be legal. But I'd follow the model of the standard
allocator; I'd guess that very few, if any, implementations are
tested with anything really exotic.)
I am not sure if I understand your suggestion. My allocators name is
SharedMemAlloc, so do I do the conversion that you suggested:
Allocator< T > a( b ) ;
Where? I don't see any user defined constructors or conversion
operators in SharedMemAlloc, and the compiler isn't going to
provide any generic constructor for you.
I guess I need to make sure that my allocator handles not only (void
*) argument, but also std::_List_node<void* > >.
That's what the standard says. You must be able to create an
allocator of type SharedMemAlloc< T1 > by copying an allocator
of type SharedMemAlloc< T0 >. On the other hand, you don't need
to be able to construct an allocator instance from a void*
(which you don't support either); just from an allocator of a
different type.
I do not know how you write it in C++.
It's your allocator, so if you don't know, no one does:-).
If the allocator has no state, it is trivial. The template
constructor is empty. If the allocator has the same state for
all allocated types, then that state must be copied. If the
allocator has state which depends on the allocated type, then
you'll have to figure out how to generically map that state.
If the above declaration of SharedMemAlloc is complete, then it
has no state (which sort of surprises me; I'd expect at least a
pointer to the actual object which manages the shared memory).
So just adding:
template< typename U >
SharedMemAlloc( SharedMemAlloc< U > const& ) {}
to the class template definition should do the trick.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34