Geek asks and answers

C ++: std :: vector [] operator

Why does std :: vector have 2 []implementation operators ?

reference       operator[]( size_type pos );
const_reference operator[]( size_type pos ) const;
+4
source share
4 answers

One for a non-constant vector object, and the other for a const const object.

void f(std::vector<int> & v1, std::vector<int> const & v2)
{
   //v1 is non-const vector
   //v2 is const vector

   auto & x1 = v1[0]; //invokes the non-const version
   auto & x2 = v2[0]; //invokes the const version

   v1[0] = 10; //okay : non-const version can modify the object
   v2[0] = 10; //compilation error : const version cannot modify 

   x1 = 10; //okay : x1 is inferred to be `int&`
   x2 = 10; //error: x2 is inferred to be `int const&`
}

As you can see, the non-const version allows you to change a vector element using an index, and the version constdoes NOT allow you to change vector elements. This is the semantic difference between the two versions.

For more details, see this FAQ:

Hope this helps.

+8
source

To make this differentiation possible:

// const vector object, cannot be modified
// const operator[] allows for this
int get_value(const std::vector<int>& vec, size_t index)
{
   return vec[index];
}

// non-const vector object can be modified
// non-const operator[] allows for this
void set_value(std::vector<int>& vec, size_t index, int val)
{
   vec[index] = value;
}

std::vector<int> values;
values.push_back(10);
values.push_back(20);

set_value(values, 0, 50);
get_value(values, 0);
+1
source

one, (non const) vector

void foo( std::vector<int>& vector )
{
    // reference operator[]( size_type );
    int old = vector[0];
    vector[0] = 42;
}

, const-

void foo( std::vector<int> const& vector )
{
    //const_reference operator[]( size_type ) const;
    int i = vector[0];

}
+1

One of the two overloads allows you to get a link constto a vector element accessed through a variable const. Another allows you to get a link not constto an element of a vector that is accessed through a variable const.

If you did not have a version const, you will not be allowed to compile the following instances:

void f(vector<int> const& v)
{
    cout << v[0]; // Invokes the const version of operator []
}

In the following example, a non-constant version is called instead, which returns a reference not constto the first element in the array and allows, for example, to assign a new value to it:

void f(vector<int>& v)
{
    v[0] = 1; // Invokes the non-const version of operator[]
}
0
source

More articles:


All Articles