带有包装随机访问的C++向量？

Question

我真正想要的是 C++ 中的容器类，它在各方面都与 STL 向量类完全相同，只是 [] 运算符具有包装行为。例如：

vector<int>  myVec;
myVec.push_back(5);
myVec.push_back(10);
myVec.push_back(15);

cout << myVec[ 5] << endl;   // would output 15
cout << myVec[ 1] << endl;   // would output 10
cout << myVec[-2] << endl;   // would output 10

这样的容器是否已经存在，或者是否可以重载或重新定义向量模板中的 [] 运算符？

我见过Boost circular buffer，它的行为不是这样的。

Answer 1

这样的容器是否已经存在

至少不在标准库中。

是否可以重载或重新定义向量模板中的 [] 运算符？

不，您不能重载或重新定义 std::vector 的 [] 运算符。

当然可以编写具有您所描述行为的重载T& operator[](int pos) 的包装器。像这样：

T& operator[](int pos) {
    std::vector<T>::size_type fancy_pos =
        pos < 0 ? data.size() + pos
                : pos - 1;
    return data[fancy_pos];
}

Answer 2

在 C++ 中，容器的索引从 0 开始。

您可以将标准容器 std::vector 包装在一个类中并重载运算符 []，这样索引的计算方式类似于 index = index % size() 或 index %= size()

Answer 3

您正在寻找循环缓冲区或循环缓冲区。

Boost 有它们：

• http://www.boost.org/doc/libs/1_61_0/doc/html/circular_buffer.html

它们有时大大比例如使用 std::deque 滚动您自己，请参阅 ASIO 的此示例：

• boost 1.55 asio tcp cpp03 chat_server example memory leaks

---

更新

我认为 boost::circular_buffer 可能是您/应该想要的/ - 因为它抽象了您通常想要的大多数任务的“如何”。但是，创建自己的适配器类型非常简单：

Live On Coliru

#include <vector>

namespace mylib {
    template <typename T, typename Container = std::vector<T> >
    struct circular : Container {
        using Container::Container;
        using Container::operator =;

        auto& operator[](int i) const {
            // mixed signed/unsigned modulo is undefined
            while (i<0) i += Container::size();
            return Container::operator[](i % Container::size());
        }

        auto& operator[](int i) {
            while (i<0) i += Container::size();
            return Container::operator[](i % Container::size());
        }
    };
}

#include <iostream>

template <typename Whatever>
void test(Whatever const& data) {
    std::cout << data[ 5] << ", "; // would output 15
    std::cout << data[ 1] << ", "; // would output 10
    std::cout << data[-2] << std::endl; // would output 10
}

#include <string>
#include <deque>
int main() {
    test(mylib::circular<int>                                   { 5, 10, 15                }); 
    test(mylib::circular<std::string>                           { "five", "teen", "fiteen" }); 
    test(mylib::circular<std::string, std::deque<std::string> > { "five", "teen", "fiteen" }); 
    test(mylib::circular<int, std::deque<float> >               { 5, 10, 15                }); 
}

打印：

15, 10, 10
fiteen, teen, teen
fiteen, teen, teen
15, 10, 10