c++ - 如何为VC++ 17/20现代化分配器适配器

我有一个分配器适配器，称为ctor_allocator。我写的更多是出于实验目的，而不是为了任何实际需要。它使分配器在可行时使用默认构造，从而通过赋值绕过任何默认初始化。例如，构造double的 vector 不会将值初始化为0.0(或任何其他值)。

适配器中的许多代码都是过时的，如果还没有出现，它可能会很快被弃用。我还没有在不破坏其目的的情况下使代码现代化。例如，如果删除struct rebind模板，则返回零初始化。

您可以显示如何对其进行现代化吗？

答案可能对其他应用程序具有指导意义。

编辑:在评论中，布兰登给出了这两个链接，作为“新方法”的示例。 SO question和Minimal example。两者都不能阻止在construct中发生的零初始化。但是，如果我通过添加void construct(U* ptr)模板来修改任一示例，则避免了零初始化。这回答的问题与我在这里提出的问题不同，但这是对一个很好的问题的很好的回答。

#include <memory>
namespace dj {
    template <typename T, typename A = std::allocator<T>>
    class ctor_allocator : public A
    {
        using a_t = std::allocator_traits<A>;
    public:
        using A::A; // Inherit constructors from A
        template <typename U>
        struct rebind {
            using other  = ctor_allocator<U, typename a_t::template rebind_alloc<U>>;
        };

        template <typename U>
        void construct(U* ptr)
            noexcept(std::is_nothrow_default_constructible<U>::value)
        {
            ::new(static_cast<void*>(ptr)) U;
        }

        template <typename U, typename...Args>
        void construct(U* ptr, Args&&... args) {
            a_t::construct(static_cast<A&>(*this),
                ptr, std::forward<Args>(args)...);
        }
    };
}

// Test case. main.cpp
#include <iostream>
#include <vector>

template<class T>
using vector = std::vector<T, dj::ctor_allocator<T>>;

int main() {
    {
        vector<int> v(10);
        for (int i = 0; i < 10; ++i) {
            v[i] = i * 56313;
        }
    }
    // If ctor_allocator works as intended,
    // this probably will not print all zeros.
    vector<int> v(10);
    for (int i = 0; i < 20; ++i) {
        std::cout << std::hex << v[i] << " ";
    }
    std::cout << std::endl;
}

最佳答案

多亏了布兰登的提示，我才弄清楚了-至少是大部分。一种可能的解决方案是将allocate和deallocate委托(delegate)给基类，而不是从基类继承。至少在VC++ 2017上，我仍然需要对construct进行特化处理，尽管我看到的文档证明我提供的特化正是默认值。

以下内容可能需要一些复制构造函数和赋值运算符的内容。请指教。

#include <memory>

namespace dj {

template<typename T, typename Base = std::allocator<T>>
struct ctor_allocator
    {
        Base A;
        using value_type = typename Base::value_type;
        using pointer = typename Base::pointer;

        pointer allocate(std::size_t n, const void* hint = 0)
        {
            auto ret = A.allocate(n,hint);
            return ret;
        }

        void deallocate(pointer ptr, std::size_t n)
        {
            A.deallocate(ptr, n);
        }

        template <typename U >
        void construct(U* ptr) {
                ::new (ptr) U;
        }
    };

template <typename T, typename U>
    inline
    bool operator==(const ctor_allocator<T>& left, const ctor_allocator<U>& right)
        {
            return left.A == right.A;
        }

template <typename T, typename U>
    inline bool operator != (const ctor_allocator<T>& a, const ctor_allocator<U>& b)
        {
            return !(a == b);
        }
}

// MAIN.cpp
#include <vector>
template<class T>
using vector = std::vector<T, dj::ctor_allocator<T>>;

int main() {
    {
        vector<int> v(10);
        for (int i = 0; i < 10; ++i) {
        v[i] = i * 313;
        }
    }
    vector<int> v(20);
    for (auto i: v) {
        std::cout << std::hex << i << " ";
    }
    std::cout << std::endl;
}

关于c++ - 如何为VC++ 17/20现代化分配器适配器，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/48816306/