Question

我正在寻找一个提供容器的库，如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.In Place Factory几乎是有用的，但它不支持惰性参数。）

Answer 1

我不知道任何现成的解决方案，但是，这并不是那么难。数组的轮廓可能如下所示

#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指出的问题。 - 怎么样？ - 取决于你想要什么。将它们设为私有是一种方式。做一个非浅的副本是另一个。 - 在第二种情况下，模板实例化的机制应该在将不可复制的类应用于数组时防止出错。

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

1 个答案: