是否有任何库为非默认可构造的不可复制类型提供容器

Is there any library that provides containers for non-copyable types that are not default-contructible?

本文关键字：类型 可复制 任何库 默认 是否      更新时间：2023-10-16

我正在寻找一个提供容器的库，如std::array(编译时固定大小，但不支持聚合初始化)和std::vector(可变大小，连续内存)，适用于不可复制和不可默认构造的类型。

特别是，我希望能够将一组函数传递给构造函数，这些函数用于获取所包含对象的构造函数的参数。类似于emplace_back，但作为构造函数并使用惰性求值参数。

这是一个(自然不工作)的例子:

class stubborn_type : boost::noncopyable {
public:
    explicit stubborn_type(int value)
    : value(value)
    {}
private:
    const int value;
};
struct generate_values {
    generate_values(int initial_value = 0)
    : current_value(initial_value)
    {}
    int operator()() {
        return current_value++;
    }
private:
    int current_value;
};
/* This should create a vector containing 10 elements initialized with the values
   [0..9] in order. */
magic::vector<stubborn_type> data(10, generate_values());

我需要与c++ 03兼容的解决方案(因为这意味着没有可变模板，我更喜欢Boost方法，使用预处理器魔法为不同数量的参数生成重载，但合理的固定限制也很好)。这样的东西存在吗?如果没有，是否有任何库可以帮助实现这一目标(例如Boost。就地工厂几乎很有用，但它不支持懒惰参数)。

我不知道任何现成的解决方案，然而，这并不难做到。数组的轮廓可能看起来像这样

#include <cstddef>
typedef char saum;
// smallest addressable unit of memory
namespace magic {
    template<class T>
    class IArray
    {
        T *const _ptr;
        const size_t _length;
    public:
        operator T* () {
            return _ptr;
        }
        size_t length() const {
            return _length;
        }
    private:
        IArray<T>(T* ptr, size_t length)
            : _ptr(ptr), _length(length)
        {}
        template<class S, size_t length>
        friend class Array;
    };

    template<class T>
    class Generator
    {
    public:
        virtual void operator() (T* place) = 0;
    };

    template<class T, size_t length>
    class Array
    {
        saum buffer[sizeof(T) * length];
    public:
        Array(Generator<T>& generate) {
            for (size_t i = 0; i < length; i++)
                generate((T*)buffer + i);
        }
        ~Array() {
            for (size_t i = 0; i < length; i++)
                ((T*)buffer)[i].~T();
        }
        operator IArray<T> () {
            return IArray<T>((T*)buffer, length);
        }
        operator T* () {
            return (T*)buffer;
        }
    };
}
我有点累了，所以请原谅我没有想出更好的名字。不过，它应该能完成这项工作。也许，发电机解决方案不是太漂亮，但仍然提供了灵活性。我相信更多的羽毛不会造成问题。

一个例子
#include <new>
#include <iostream>
class Stubborn
{
public:
    Stubborn(int value) : value(value*2) { }
    const int value;
private:
    Stubborn(const Stubborn&);
    Stubborn& operator=(const Stubborn&);
};

struct StubbornGen : public magic::Generator<Stubborn>
{
    StubbornGen() : current_value(0)
    {}
    void operator() (Stubborn* place) {
        new(place) Stubborn(current_value++);
    }
private:
    int current_value;
};

void f(magic::IArray<Stubborn> stubs)
{
    std::cout << stubs[0].value << stubs[1].value
              << stubs[2].value << stubs[3].value
              << "  " << stubs.length() << std::endl;
}
int main(int argc, char *argv[])
{
    StubbornGen gen;
    magic::Array<Stubborn, 4> stubs(gen);
    f(stubs);
}

编辑:更正，感谢DyP，加上生成器调整。

为Array定义复制构造函数和赋值操作符是很重要的，以避免DyP所指出的问题。——如何?-这取决于你想要什么。让它们私人化是一种方法。进行非浅层复制是另一回事。在第二种情况下，模板实例化的机制应该防止错误，当应用一个不可复制的类到数组。

相关文章：