Question

我正在编写一个简单的模板化循环缓冲区：

template <typename T, size_t N>
class CircularBuffer {

    T      _buf[N];
    T     *_data;
    size_t _head;
    size_t _count;
    size_t _capacity;

    CircularBuffer():
            _data(nullptr),
            _head(0),
            _count(0),
            _capacity(N) {}

protected:

    T* buffer() {
        if (_count <= N) return &_buf;
        else return _data;
    }

public:

    T& operator[](size_t i) {
        size_t j = i % _count;
        j = (_head + j) % _capacity;
        return buffer()[j];
    }

    T& push_back(const T& o) {
        if (_count == _capacity) {
            dynamically_allocate_data();
        }
        size_t j = (_head + _count++) % _capcity;
        buffer()[j] = o;
    }

    T pop_front() {
        size_t old_head = _head;
        _head = (_head + 1) % _capacity;
        return buffer()[old_head];
    }

};

这是从真实的事物中剥离出来的，但相距不远，您就明白了。这样可以避免为少于N个项目的缓冲区分配内存。

问题是这不适用于没有默认构造函数的T。我可以提供CircularBuffer的构造函数-ala std::vector的构造函数，该构造函数接受T来填充空缓冲区，但是我不确定如何在没有它的情况下实际实现仍隐式调用T（可能不存在）的默认构造函数。

对类似问题的答复建议使用std::vector或将新位置放置在void*数组上，但在这种情况下不适用，因为整个目的是避免在内部循环中动态分配内存。 / p>

如何在没有默认构造函数的情况下为T构造此类？（或者，是否有另一种方案可以避免在缓冲区中开始构造空白T呢？）

Answer 1

使用std::optional（如果您的编译器为17之前的版本，则使用boost::optional怎么办？您可以将静态数组定义为std::optional<T> _buf[N];。

std::optional类型支持放置构造（因此T不需要默认的构造函数）并静态分配，这样就可以满足您的要求了吗？

为没有默认构造函数的类型初始化静态大小的数组

1 个答案: