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

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

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 2

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 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.