Как сделать мой uninitialized_allocator безопасным?

Fwiw, я думаю, что дизайн можно упростить, предполагая, что контейнер соответствует С++ 11:

template <class T>
class no_init_allocator
{
public:
    typedef T value_type;

    no_init_allocator() noexcept {}
    template <class U>
        no_init_allocator(const no_init_allocator<U>&) noexcept {}
    T* allocate(std::size_t n)
        {return static_cast<T*>(::operator new(n * sizeof(T)));}
    void deallocate(T* p, std::size_t) noexcept
        {::operator delete(static_cast<void*>(p));}
    template <class U>
        void construct(U*) noexcept
        {
            static_assert(std::is_trivially_default_constructible<U>::value,
            "This allocator can only be used with trivally default constructible types");
        }
    template <class U, class A0, class... Args>
        void construct(U* up, A0&& a0, Args&&... args) noexcept
        {
            ::new(up) U(std::forward<A0>(a0), std::forward<Args>(args)...);
        }
};

1. Я не вижу большого преимущества в получении от другого распределителя.

2. Теперь вы можете позволить allocator_traits управлять rebind.

3. Создайте шаблон для construct членов на U. Это помогает, если вы хотите использовать этот распределитель с каким-либо контейнером, которому нужно выделить что-то отличное от T (например, std::list).

4. Переместите тест static_assert в один элемент construct, где он важен.

Вы все еще можете создать using:

template <class T>
using uninitialised_vector = std::vector<T, no_init_allocator<T>>;

И это все еще не скомпилировано:

unitialised_vector< std::vector<int> > x(10);


test.cpp:447:17: error: static_assert failed "This allocator can only be used with trivally default constructible types"
                static_assert(std::is_trivially_default_constructible<U>::value,
                ^             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Я думаю, что тест для is_trivially_destructible излишен, если только вы не оптимизируете destroy так, чтобы он ничего не делал. Но я не вижу в этом никакой мотивации, так как считаю, что в любом случае это должно быть оптимизировано, когда это уместно. Без такого ограничения вы можете:

class A
{
    int data_;
public:
    A() = default;
    A(int d) : data_(d) {}
};

int main()
{
    uninitialised_vector<A> v(10);
}

И это просто работает. Но если сделать ~A() нетривиальным:

    ~A() {std::cout << "~A(" << data_ << ")\n";}

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

test.cpp:447:17: error: static_assert failed "This allocator can only be used with trivally default constructible types"
                static_assert(std::is_trivially_default_constructible<U>::value,
                ^             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

т.е. A больше нельзя построить тривиально, если у него есть нетривиальный деструктор.

Однако даже с нетривиальным деструктором вы все равно можете:

    uninitialised_vector<A> v;
    v.push_back(A());

Это работает только потому, что я не переборщил с требованием тривиального деструктора. И при выполнении этого я получаю ~A() для работы, как и ожидалось:

~A(0)
~A(0)