6

我正在寻找一个提供容器的库，例如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());

我需要 to 解决方案与 C++03 兼容（因为这意味着没有可变参数模板，我更喜欢使用预处理器魔术为不同数量的参数生成重载的 Boost 方法，但合理的固定限制也可以）。这样的事情存在吗？如果没有，是否有任何库可以帮助实现该目标（例如，Boost.In Place Factory几乎很有用，但它不支持惰性参数）。

4

1 回答 1

2

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

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

于 2013-05-15T01:58:01.843 回答