Не копируемый STL Allocator

Question

Я хочу создать не копируемый распределитель (в C ++ 14), который просто выделяет фиксированный блок памяти, который может использовать std::vector.Я хочу предотвратить копирование распределителя (и, следовательно, также вектора), чтобы предотвратить случайное выделение памяти пользователем.Распределитель предназначен только для использования с std::vector или, может быть, std::string.

Так что мой распределитель имеет конструктор копирования, подобный этому:

static_allocator(const static_allocator<T>&) = delete;

При вызове:

std::vector<int, static_allocator<int>> vvv(static_allocator<int>(3));

Я получаю следующую ошибку компиляции:

/usr/include/c++/5/bits/stl_vector.h: In instantiation of ‘std::_Vector_base<_Tp, _Alloc>::_Vector_impl::_Vector_impl(const _Tp_alloc_type&) [with _Tp = int; _Alloc = static_allocator<int>; std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type = static_allocator<int>]’:
/usr/include/c++/5/bits/stl_vector.h:128:20:   required from ‘std::_Vector_base<_Tp, _Alloc>::_Vector_base(const allocator_type&) [with _Tp = int; _Alloc = static_allocator<int>; std::_Vector_base<_Tp, _Alloc>::allocator_type = static_allocator<int>]’
/usr/include/c++/5/bits/stl_vector.h:265:18:   required from ‘std::vector<_Tp, _Alloc>::vector(const allocator_type&) [with _Tp = int; _Alloc = static_allocator<int>; std::vector<_Tp, _Alloc>::allocator_type = static_allocator<int>]’

Ошибка возникает, по-видимому, из-за того, что в stl_vector.h:265 нет конструктора для определенных распределителей rvalue:

/**
*  @brief  Creates a %vector with no elements.
*  @param  __a  An allocator object.
*/
explicit
vector(const allocator_type& __a) _GLIBCXX_NOEXCEPT
: _Base(__a) { }

Хотя код глубже фактически поддерживает распределители rvalue, но они не вызываются, потому что rvalue берется по ссылке конструктором, упомянутым выше.

Является ли это отсутствующей функцией в C ++ 14 или я отсутствуеткакой-то вариант?Также странно, что распределитель копируется при построении вектора без очевидных причин.

Полный пример кода можно найти здесь: https://onlinegdb.com/ByqXwQ4k4

Answer 1

Это невозможно.From [container.requirements.general] / 8

[...] Все остальные конструкторы для этих типов контейнеров принимают аргумент const allocator_­type& .[Примечание: если при вызове конструктора используется значение по умолчанию необязательного аргумента распределителя, тип распределителя должен поддерживать инициализацию значения.- примечание конца] Копия этого распределителя используется для любого выделения памяти и построения элемента, выполняемого этими конструкторами и всеми функциями-членами в течение времени жизни каждого объекта контейнера или до замены распределителя.

^{выделение шахты}

Таким образом, вы не можете передать распределитель перемещения только одному из конструкторов контейнеров, которые принимают распределитель.

Answer 2

Вы сказали: Я хочу, чтобы [...] предотвратить случайное выделение памяти пользователем.

Но предлагаемое вами решение Я хочу запретить распределитель (ипоэтому также вектор) от возможности копирования , как сказано в других ответах, неосуществим.Как написано, ваш вопрос выглядит как XY проблема

У других есть ответ на вашу попытку решения .Поэтому я сосредоточусь только на проблеме.Потому что можно написать стандартный совместимый распределитель, который полностью удовлетворит ваши потребности: , чтобы предотвратить случайное выделение памяти пользователем.

Существует множество альтернативных реализаций, которые могут удовлетворить ваши потребности.Но я не знаю точно, что вы ищете, поэтому я предлагаю ниже пример, который можно адаптировать, следуя требованиям в allocator.requirements :

const size_t buffer_size = 4096;
unsigned char buffer[buffer_size];
void* _sbuffer = buffer; //or atomic



template<class T>
class allocator{
   void* buffer = exchange(_sbuffer,nullptr);//could be done atomically
   bool allocatable=buffer?true:false;

   public:

   using value_type = T;

   T* allocate(size_t n){
      if (n>buffer_size || !allocatable) throw std::bad_alloc{};
      allocatable=false;
      return static_cast<T*>(buffer);
      }
   void deallocate(T*,size_t){
      if (buffer) allocatable=true;
      }
   //Here the intersting part:
   allocator select_on_container_copy_construction(){
      return allocator{};
      }

   allocator() =default;

   //this copy constructor is only used internaly
   //but will not be used to propagate the allocator
   //from one container object to an other 
   //(see select_on_container_copy_construction)
   allocator(const allocator& other) =default;

   allocator(allocator&& other)
     :buffer{exchange(other.buffer,nullptr)}
     ,allocatable{exchange(other.allocatable,false)}
     {}
   allocator& operator=(const allocator&) =delete;
   allocator& operator=(allocator&& other){
      buffer=exchange(other.buffer,nullptr);
      allocatable=exchange(other.allocatable,false);
      return *this;
      }

   using propagate_on_container_copy_assignment = false_type;
   using propagate_on_container_move_assignment = true_type;
   using propagate_on_container_swap = true_type;


   //any allocator can deallocate memory provided by an other
   static constexpr bool is_always_equal = true;

   friend bool operator==(const allocator&,const allocator&){
       return true;
       }

   friend bool operator!=(const allocator&,const allocator&){
       return false;
       }
   };

Демонстрация на coliru

Это хрупко, потому что если распределитель создается вне контейнера, то создается копия, а эти копии позже используются для инициализации контейнеров ... Вы можете перейти к определенному поведению реализации, например, дляlibstdc ++, вы можете объявить опасный конструктор закрытым:

template<class T>
struct allocator{
   /*...*/
   friend std::_Vector_base<T,allocator>;
   friend std::allocator_traits<allocator>;
   private:
   allocator() =default;
   allocator(const allocator& other) =default;
   public:/*...*/
   };

Answer 3

В соответствии с требованиями для Allocator типа ваш тип распределителя должен удовлетворять CopyConstructible, что означает, что вы не можете удалить свою копию с:

A a1(a)
A a1 = a

Конструкции копирования a1 такие, что a1 == a.Не бросает исключения.(Примечание: каждый Allocator также удовлетворяет CopyConstructible)