Как создать C++ 11 не конструируемый по умолчанию распределитель?

Question

Эта тема возникла в этой теме об изменении std::list::sort() для Visual Studio 2015:

`std:: list<>:: sort ()` - почему внезапный переход на нисходящую стратегию?

Новая версия std:: list:: sort не требует создания по умолчанию std::list, поскольку она использует только итераторы и не создает локальных списков, поэтому не имеет значения, не могут ли списки быть по умолчанию построен. В предыдущей версии использовались локальные списки (примечание - каждый экземпляр списка включает динамическое выделение сторожевого узла):

typedef list<_Ty, _Alloc> _Myt;
    // ...
   const size_t _MAXBINS = 25;
   _Myt _Templist, _Binlist[_MAXBINS];

Я пытаюсь создать неконтролируемый список по умолчанию, с версией Visual Studio 2015, чтобы проверить, как изменение в std::list::sort() справляется с этим.

Сначала я попробовал пример минимального распределителя Microsoft C++ 11. udpate - мне пришлось изменить одну строку, чтобы ответ Джонатана Уэйкли сработал и продемонстрировал проблему:

template <class T>  
struct Mallocator  
{  
    typedef T value_type;  
//  Mallocator() noexcept {}  // replaced this line from the Microsoft example
    Mallocator(T) noexcept {} // no default constructor

    // A converting copy constructor:  
    template<class U> Mallocator(const Mallocator<U>&) noexcept {}  
    template<class U> bool operator==(const Mallocator<U>&) const noexcept  
    {  
        return true;  
    }  
    template<class U> bool operator!=(const Mallocator<U>&) const noexcept  
    {  
        return false;  
    }  
    T* allocate(const size_t n) const;  
    void deallocate(T* const p, size_t) const noexcept;  
};  

template <class T>  
T* Mallocator<T>::allocate(const size_t n) const  
{
    if (n == 0)  
    {  
        return nullptr;  
    }  
    if (n > static_cast<size_t>(-1) / sizeof(T))  
    {  
        throw std::bad_array_new_length();  
    }  
    void* const pv = malloc(n * sizeof(T));  
    if (!pv) { throw std::bad_alloc(); }  
    return static_cast<T*>(pv);  
}  

template<class T>  
void Mallocator<T>::deallocate(T * const p, size_t) const noexcept  
{  
    free(p);  
}  

обновление - с измененным Mallocator, чтобы не иметь конструктора по умолчанию, это теперь приводит к ошибке компиляции:

typedef unsigned long long uint64_t;
    std::list <uint64_t, Mallocator<uint64_t>> dll; // doubly linked list

Использование предложенного изменения от Джонатана Уэйкли работает и воспроизводит проблему, при которой старый std:: list:: sort получает ошибку компиляции из-за локальных списков и показывает, что новый std:: list:: sort без локальных списков работает без значения по умолчанию конструктор:

    std::list<uint64_t, Mallocator<uint64_t>> dll(Mallocator<uint64_t>(0));

Я также попробовал этот метод на основе потока здесь, в SO:

struct Allocator {
    void construct(void* p, const void* container) const {};
    void destruct(void* p, const void* container) const {};
};

void* operator new (size_t size, const Allocator& alloc, const void* container)
{
    void* allocated_memory = std::malloc(size);
    if (!allocated_memory) {
        throw std::bad_alloc();
    }

    alloc.construct(allocated_memory, container);
    return allocated_memory;
}

void operator delete(void* p, const Allocator& alloc, const void* container)
{
    alloc.destruct(p, container);
    std::free(p);
}

В основном

typedef unsigned long long uint64_t;
// ...
    Allocator alloc;
    std::list<uint64_t> *dll = new(alloc, NULL)std::list<uint64_t>;
    // ...
    operator delete(dll, alloc, NULL);

но это работает как для старых, так и для новых версий std:: list:: sort, поэтому он получает конструктор по умолчанию.

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

Благодаря демонстрации от Игоря Тандетни и ответа от Джонатана Уэйкли, я смог изменить приведенный выше пример Microsoft (отмечено в комментариях), чтобы не иметь конструктора по умолчанию, и воспроизвести проблему, связанную со старым std:: list:: Сортировать.

Answer 1

Если вы по умолчанию создаете std::list тогда он по умолчанию создаст свой распределитель, так что для определения этой переменной все еще требуется конструктор по умолчанию:

std::list <uint64_t, Mallocator<uint64_t>> dll; // doubly linked list

Если вы хотите протестировать распределители без конструкторов по умолчанию, вам нужно сделать это по-другому, например

std::list <uint64_t, Mallocator<uint64_t>> dll(Mallocator<uint64_t>(args));

Или же:

Mallocator<uint64_t> alloc(some, args, for, your, allocator);
std::list <uint64_t, Mallocator<uint64_t>> dll(alloc);