C++Talk.NET

Oliver S. · Guest

Da mir häufig bei std::string-Operationen auf die Nerven gegangen ist,
daß die durch die std::allocator<T>-Operationen ziemlich lahmarschig ist,
habe ich mir eine eigene Speicherverwaltungs-Library gezimmert und dieser
auch einen STL-konformen Allocator mitgegeben. Da ich zwei dieser Dinger
für verschiedene Speicherpools benötige (einmal globaler Heap und einmal
Thread-lokaler Heap, je nachdem wieviel Performnace man will bzw Thread
-lokalen Verschnitt man hinnehmen will), habe ich beide Allocator auf
einer gemeinsmen Basisklasse aufgebaut; die sieht so aus:

template<typename T>
class mallocator_base
{
public:
typedef T const &const_pointer;
typedef T const &const_reference;
typedef std::ptrdiff_t difference_type;
typedef T *pointer;
typedef T &reference;
typedef std::size_t size_type;
typedef T value_type;

template<class Other>
struct rebind
{
typedef mallocator_base<Other> other;
};

public:
mallocator_base();
static pointer address( reference t );
static const_pointer address( const_reference t );
template<typename ValType>
static void construct( pointer ptr, ValType &val );
static void destroy( pointer ptr );
static size_type max_size();
template<typename Other>
mallocator_base &operator =( Other const &other );

private:
static pointer allocate( size_type count, void * = NULL );
static void deallocate( pointer ptr, size_type count );
};

template<typename T>
inline
mallocator_base<T>::mallocator_base()
{
}

template<typename T>
inline
typename mallocator_base<T>::pointer mallocator_base<T>::address(
reference t )
{
return &t;
}

template<typename T>
inline
typename mallocator_base<T>::const_pointer mallocator_base<T>::address(
const_reference t )
{
return &t;
}

template<typename T>
template<typename ValType>
inline
void mallocator_base<T>::construct( pointer ptr, ValType &val )
{
new( ptr )T( val );
}

template<typename T>
inline
void mallocator_base<T>::destroy( pointer ptr )
{
ptr->T::~T();
}

template<typename T>
inline
typename mallocator_base<T>::size_type mallocator_base<T>::max_size()
{
return (size_type)(int_t)-1;
}

template<typename T>
template<typename Other>
mallocator_base<T> &mallocator_base<T>::operator =( Other const &other )
{
}

Dann gibt es z.B eine weiter darauf aufbauende Klasse global_mallocator<T>.
Die hat zusätztlich noch die allocate()- und deallocate()-Methoden:

template<typename T>
class global_mallocator : public mallocator_base<T>
{
public:
global_mallocator();
static pointer allocate( size_type count, void *hint = NULL );
static void deallocate( pointer ptr, size_type count );
};

template<typename T>
inline
global_mallocator<T>::global_mallocator() :
mallocator_base<T>()
{
}

template<typename T>
inline
typename global_mallocator<T>::pointer global_mallocator<T>::allocate(
size_type count, void * )
{
return (pointer)Mallocator::Allocate( count );
}

template<typename T>
inline
void global_mallocator<T>::deallocate( pointer ptr, size_type count )
{
Mallocator::Release( ptr );
}

Wenn ich nun aber versuche meinen Allocator zu benutzen:

...
typedef std::basic_string<char, std::char_traits global_mallocator<char> > faststring;
faststring str;
...

Dann bekomme ich folgenden Compiler-Fehler, der darauf hinweist, daß die
allocate()-Methode meines Allocators nicht benutzt werden kann:

xstring(1517):
error C2039: 'deallocate': Ist kein Element von
'ns_OClasses::mallocator_base<T>'

Meine STL-Implementation ist also somit nicht in der Lage auf
global_mallocator<char>::allocate zuzugrifen. Und nicht nur das,
mein Compiler menit auch noch diese Funktion in der übergeordeten
mallocator_base<char> suchen zu müssen; warum auch immer.

Kann mir einer da weiterhelfen?

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Torsten Robitzki · Guest

Oliver S. wrote:

Thomas Maeder · Guest

"Oliver S." <Follow.Me (AT) gmx (DOT) net> writes:

Oliver S. · Guest

Oliver S. · Guest

Torsten Robitzki · Guest

Oliver S. wrote: