std::map allocator

[Marcos Bracco]

Una consulta sobre implementaciones de std::map, por si alguien se la sabe y me evita tener que revisarlas yo mismo.

cuando yo uso un std::map<Key, Value>, el allocador que lleva es un allocator<std::pair<Key, Value>>

template<

    class Key,
    class T,
    class Compare = std::less<Key>,
    class Allocator = std::allocator<std::pair<const Key, T> >

> class map;

Ahora, el std::map usa un arbol y el arbol necesita nodos internos para ordenar los datos. Y esos nodos internos, como se allocan???

Saludos,

Marcos

[dgutson .]

JA!

 allocator_traits.

Te cuento la parte vieja:

Antes de C++14, un allocator type te proveía un template struct rebind (o algo así) que vos le decías: che allocator,

dame un allocator de este otro tipo de dato. Generalmente lo que hacían era typedef Yo<T> result;

entonces el mapa le pedía

typename allocator::rebind<Nodo>::result o algo así.

ESO SE DEPRECÓ.

En un rato copio y pego código que hice hace unos meses con la versión nueva.

--
--
¿Eres miembro de "CyC++ Buenos Aires" verdad? Si no lo eres, has recibido este mesaje por error.
En caso de duda visita "http://groups.google.com/group/cppba"
---
Has recibido este mensaje porque estás suscrito al grupo "CyC++ Buenos Aires" de Grupos de Google.
Para cancelar la suscripción a este grupo y dejar de recibir sus mensajes, envía un correo electrónico a cppba+unsubscribe@googlegroups.com.
Para acceder a más opciones, visita https://groups.google.com/d/optout.

--

Who’s got the sweetest disposition?
One guess, that’s who?
Who’d never, ever start an argument?
Who never shows a bit of temperament?
Who's never wrong but always right?
Who'd never dream of starting a fight?
Who get stuck with all the bad luck?

[dgutson .]

(perdón es hasta c++17)

o sea

template <class T>

struct MyAllocator

{

    template <class NewType>

    struct rebind

    {

        typedef MyAllocator<NewType> other;      // no necesariamente MyAllocator, puede ser otro

    };

};

Yo era muy feliz con esa simpleza.

[dgutson .]

Te pongo el equivalente, esto es código en producción (con censura, obviamente) que hice para un allocator usado en strings:

template<class BaseAllocator>

struct PlinPlinAllocator : public BaseAllocator

{

    using typename BaseAllocator::value_type;

    using BaseAllocator::BaseAllocator;

    void deallocate(value_type* p, std::size_t n)

    {

        // se pinchó la nariz

        BaseAllocator::deallocate(p, n);

    }

};

template <class BaseAllocator>

class std::allocator_traits<PlinPlinAllocator<BaseAllocator>> : public std::allocator_traits<BaseAllocator>

{

public:

    using allocator_type = PlinPlinAllocator<BaseAllocator>;

    static allocator_type select_on_container_copy_construction(const allocator_type& a)

    {

        return allocator_type(a);

    }

    // estas dos son backward compatible:

    template <class T>

    using rebind_alloc = PlinPlinAllocator<typename std::allocator_traits<BaseAllocator>::template rebind_alloc<T>>;

    template <class T>

    using rebind_traits = std::allocator_traits<rebind_alloc<T>>;

};

Me llevó tiempo entender y hacer ésto :)  si hay dudas preguntame.

Espero haberte ahorrado todo el reniegue que me llevó a mí.

Dato: lo del BaseAllocator es simplemente porque quiero que mi plin plin allocator EXTIENDA al std::allocator, pero para vos es completamente opcional.

[Marcos Bracco]

Buenisimos datos, Gracias!!!