How to get a std::vector that supports negative indices? - c++

Question

I have a vector. What I want to do is store a value at the first index of the vector. However, this value is for errors and so I would like to refer to this value like vector_ [-1]. How do I go about with this?
I came up with one solution.
What I'm doing is creating a new vector and assigning the new vector to this vector.
vector_.resize(required_size+1);
vector_ = std::vector<T> (vector_.begin()+1,vector_.end());
At this point could I legally use vector_[-1]? If not, please help me with other solutions.
EDIT
I found a workaround. Though its not vectors with negative indexing, I'm using a pointer to the second member of the vector so when I do ptr[-1], it points to the first element of the vector.

Answer 1

Here's the basic starting point of a vector where you can specify the (signed) lower and upper indexes
#include <vector>
#include <cassert>
#include <iostream>
#include <iomanip>
template<class T>
struct any_index_vector
{
any_index_vector(int min, int max)
: _zero_index(min)
, _storage((max - min))
{
// assert min - max
}
T& operator[](int index)
{
assert(index >= lower_limit());
assert(index <= upper_limit());
return _storage[index - _zero_index];
}
T& operator[](int index) const
{
assert(index >= lower_limit());
assert(index <= upper_limit());
return _storage[index - _zero_index];
}
int upper_limit() const {
return _zero_index + int(_storage.size());
}
int lower_limit() const {
return _zero_index;
}
int extent() const {
return upper_limit() - lower_limit();
}
int _zero_index = 0;
std::vector<T> _storage {};
};
int main()
{
any_index_vector<int> v(-1, 9);
for (int i = -1 ; i < 10 ; ++i) {
v[i] = (i+6);
}
for (int i = -1 ; i < 10 ; ++i) {
std::cout << "position: " << std::setw(2) << i << " : " << v[i] << std::endl;
}
}
expected output:
position: -1 : 5
position: 0 : 6
position: 1 : 7
position: 2 : 8
position: 3 : 9
position: 4 : 10
position: 5 : 11
position: 6 : 12
position: 7 : 13
position: 8 : 14
position: 9 : 15

Answer 2

You can not have negative indices in c++-standard-library, unless of course you provide your own class of a vector that decays that.
For, example check the ref:
Prototype: reference operator[] (size_type n);
Parameters: n Position
of an element in the container. Notice that the first element has a
position of 0 (not 1). Member type size_type is an unsigned integral
type.
Here is a class that could do what you want:
// Example program
#include <iostream>
#include <string>
#include <vector>
class myVector {
public:
int get(int index) { return v[index + 1]; }
void push_back(int value) { v.push_back(value); }
void print() {
for(unsigned int i = 0; i < v.size(); ++i)
std::cout << v[i] << " ";
std::cout << "\n";
}
const int& operator[](int index) const { return v[index + 1]; }
private:
std::vector<int> v;
};
int main() {
myVector v;
v.push_back(404); // error code
v.push_back(32); // real data
v.print();
std::cout << v[-1] << std::endl;
std::cout << v.get(-1) << std::endl;
return 0;
}
Output (Live Demo):
404 32
404
404
Since you are new to C++, operator overloading might puzzle you, skip it for now and come back later and read Operator overloading.

Answer 3

I dont understand why you want to do this. You could as well store the extra value in the first element and access it via vector_[0]. However, if you insist on using -1 as index, then I see only one proper way to do this:
template<typename T>
class {
public:
T& operator[](int index){
if (index==-1) { return value; }
else { return vector[index]; }
}
private:
T value;
std::vector<T> vector;
}
However, I would strongly suggest not to start something like this. You will waste lots of code just to get something that acts similar to a vector while you could simply use a plain std::vector and forget about the -1 indexing.