Как реализован распределитель в C ++?

Question

Я пытался немного лучше понять std::allocator в C ++, я натолкнулся на этот вопрос , и мне кажется, что на самом деле только один класс-распределитель обычно используется контейнерами (например, std::vector) мой вопрос, как реализован такой распределитель? Это как стек, который периодически перераспределяется? Если нет, то как это на самом деле реализовано?

Answer 1

Распределители просто предоставляют политику для выделения памяти, освобождения памяти, конструирования объектов и их уничтожения.

Они не предоставляют политику для перераспределения памяти (увеличение размера ранее выделенной области памяти). Так во всех контейнерах, если память должна быть увеличена:

• либо контейнер выделяет новый фрагмент памяти,
• или, как это делает vector, выделите новую большую область памяти, скопируйте старые элементы внутри нее и затем освободите предыдущую область памяти.

Answer 2

Распределитель по умолчанию - std::allocator, и он просто использует ::operator new, как и когда требуется, поэтому ничего особенного.Это более или менее то же самое, что делать new и delete самостоятельно для каждого необходимого объекта.Вы можете прочитать больше об этом в разделе [default.allocator] в стандарте.

«Интерфейс» распределителя (на самом деле просто набор требований, применяемый при создании экземпляра шаблона) - это оболочка для этого процесса, позволяющая использовать альтернативные подходы к выделению памяти.чтобы быть занятым.

Например, альтернативные распределители, которые вы можете предоставить, могут реализовать пул памяти или что-то еще, что соответствует вашим потребностям, сокращая динамическое распределение честности.

Стандартные контейнеры, а также тип их элементов имеют тип распределителя в качестве аргумента шаблона (вы обычно этого не замечаете!), И именно так вы выбираете альтернативные реализации для использования с этим контейнером.

В этих случаях вы, как правило, будете предварительно выделять какой-то большой кусок памяти, а затем распределять маленькие куски по мере необходимости.В этом смысле такую ​​реализацию можно считать своего рода «кучей в куче», но на самом деле нет причин, по которым вам вообще нужно указывать семантику кучи.Нужно только соблюдать требования концепции Распределитель .

Мистер Джосуттис привел (скучный) пример в http://www.josuttis.com/cppcode/allocator.html; Я воспроизводлюэто здесь:

/* The following code example is taken from the book
 * "The C++ Standard Library - A Tutorial and Reference"
 * by Nicolai M. Josuttis, Addison-Wesley, 1999
 *
 * (C) Copyright Nicolai M. Josuttis 1999.
 * Permission to copy, use, modify, sell and distribute this software
 * is granted provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied
 * warranty, and with no claim as to its suitability for any purpose.
 */
#include <limits>
#include <iostream>

namespace MyLib {
   template <class T>
   class MyAlloc {
     public:
       // type definitions
       typedef T        value_type;
       typedef T*       pointer;
       typedef const T* const_pointer;
       typedef T&       reference;
       typedef const T& const_reference;
       typedef std::size_t    size_type;
       typedef std::ptrdiff_t difference_type;

       // rebind allocator to type U
       template <class U>
       struct rebind {
           typedef MyAlloc<U> other;
       };

       // return address of values
       pointer address (reference value) const {
           return &value;
       }
       const_pointer address (const_reference value) const {
           return &value;
       }

       /* constructors and destructor
        * - nothing to do because the allocator has no state
        */
       MyAlloc() throw() {
       }
       MyAlloc(const MyAlloc&) throw() {
       }
       template <class U>
         MyAlloc (const MyAlloc<U>&) throw() {
       }
       ~MyAlloc() throw() {
       }

       // return maximum number of elements that can be allocated
       size_type max_size () const throw() {
           return std::numeric_limits<std::size_t>::max() / sizeof(T);
       }

       // allocate but don't initialize num elements of type T
       pointer allocate (size_type num, const void* = 0) {
           // print message and allocate memory with global new
           std::cerr << "allocate " << num << " element(s)"
                     << " of size " << sizeof(T) << std::endl;
           pointer ret = (pointer)(::operator new(num*sizeof(T)));
           std::cerr << " allocated at: " << (void*)ret << std::endl;
           return ret;
       }

       // initialize elements of allocated storage p with value value
       void construct (pointer p, const T& value) {
           // initialize memory with placement new
           new((void*)p)T(value);
       }

       // destroy elements of initialized storage p
       void destroy (pointer p) {
           // destroy objects by calling their destructor
           p->~T();
       }

       // deallocate storage p of deleted elements
       void deallocate (pointer p, size_type num) {
           // print message and deallocate memory with global delete
           std::cerr << "deallocate " << num << " element(s)"
                     << " of size " << sizeof(T)
                     << " at: " << (void*)p << std::endl;
           ::operator delete((void*)p);
       }
   };

   // return that all specializations of this allocator are interchangeable
   template <class T1, class T2>
   bool operator== (const MyAlloc<T1>&,
                    const MyAlloc<T2>&) throw() {
       return true;
   }
   template <class T1, class T2>
   bool operator!= (const MyAlloc<T1>&,
                    const MyAlloc<T2>&) throw() {
       return false;
   }
}

И использование:

#include <vector>
#include "myalloc.hpp"

int main()
{
    // create a vector, using MyAlloc<> as allocator
    std::vector<int,MyLib::MyAlloc<int> > v;

    // insert elements
    // - causes reallocations
    v.push_back(42);
    v.push_back(56);
    v.push_back(11);
    v.push_back(22);
    v.push_back(33);
    v.push_back(44);
}