C++ vector with wrapping random access? - c++

Question

What I would really like is a container class in C++, which is exactly like the STL vector class in every way, except that the [] operator has wrapping behaviour. For example:
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
Does such a container already exist, or is it possible to overload or redefine the [] operator in the vector template?
I have seen the Boost circular buffer, and it does not behave in this way.

Answer 1

Does such a container already exist
Not in standard library at least.
is it possible to overload or redefine the [] operator in the vector template?
No, you cannot overload or redefine [] operator of std::vector.
It is certainly possible to write a wrapper with an overloaded T& operator[](int pos) that has the behaviour that you describe. Like this:
T& operator[](int pos) {
std::vector<T>::size_type fancy_pos =
pos < 0 ? data.size() + pos
: pos - 1;
return data[fancy_pos];
}

Answer 2

In C++ indices for containers start from 0.
You could wrap the standard container std::vector in a class and overload operator [] such a way that the index is calculated like index = index % size() or index %= size()

Answer 3

You are looking for a cyclic buffer or a circular buffer.
Boost has them:
http://www.boost.org/doc/libs/1_61_0/doc/html/circular_buffer.html
They are sometimes vastly better performing than e.g. rolling your own with std::deque, see this sample from ASIO:
boost 1.55 asio tcp cpp03 chat_server example memory leaks
Update
I maintain boost::circular_buffer is probably what you /should want/ - because it abstracts away the "how" for most tasks that you'd usually want this for. However, it's dead simple to create your own adaptor type:
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 });
}
Prints:
15, 10, 10
fiteen, teen, teen
fiteen, teen, teen
15, 10, 10