13.9 — Overloading the subscript operator

By Alex on October 19th, 2007 | last modified by Alex on December 21st, 2020

When working with arrays, we typically use the subscript operator ([]) to index specific elements of an array:

1	myArray[0] = 7; // put the value 7 in the first element of the array

However, consider the following IntList class, which has a member variable that is an array:

1 2 3 4 5 6 7 8 9 10 11 12

class IntList { private:     int m_list[10]{}; };   int main() {     IntList list{};     // how do we access elements from m_list?     return 0; }

Because the m_list member variable is private, we can not access it directly from variable list. This means we have no way to directly get or set values in the m_list array. So how do we get or put elements into our list?

Without operator overloading, the typical method would be to create access functions:

1 2 3 4 5 6 7 8 9

class IntList { private:     int m_list[10]{};   public:     void setItem(int index, int value) { m_list[index] = value; }     int getItem(int index) const { return m_list[index]; } };

While this works, it’s not particularly user friendly. Consider the following example:

1 2 3 4 5 6 7

int main() {     IntList list{};     list.setItem(2, 3);       return 0; }

Are we setting element 2 to the value 3, or element 3 to the value 2? Without seeing the definition of setItem(), it’s simply not clear.

You could also just return the entire list and use operator[] to access the element:

1 2 3 4 5 6 7 8

class IntList { private:     int m_list[10]{};   public:     int* getList() { return m_list; } };

While this also works, it’s syntactically odd:

1 2 3 4 5 6 7

int main() {     IntList list{};     list.getList()[2] = 3;       return 0; }

Overloading operator[]

However, a better solution in this case is to overload the subscript operator ([]) to allow access to the elements of m_list. The subscript operator is one of the operators that must be overloaded as a member function. An overloaded operator[] function will always take one parameter: the subscript that the user places between the hard braces. In our IntList case, we expect the user to pass in an integer index, and we’ll return an integer value back as a result.

1 2 3 4 5 6 7 8 9 10 11 12 13

class IntList { private:     int m_list[10]{};   public:     int& operator[] (int index); };   int& IntList::operator[] (int index) {     return m_list[index]; }

Now, whenever we use the subscript operator ([]) on an object of our class, the compiler will return the corresponding element from the m_list member variable! This allows us to both get and set values of m_list directly:

1 2 3 4 5

IntList list{};     list[2] = 3; // set a value     std::cout << list[2] << '\n'; // get a value       return 0;

This is both easy syntactically and from a comprehension standpoint. When list[2] evaluates, the compiler first checks to see if there’s an overloaded operator[] function. If so, it passes the value inside the hard braces (in this case, 2) as an argument to the function.

Note that although you can provide a default value for the function parameter, actually using operator[] without a subscript inside is not considered a valid syntax, so there’s no point.

Why operator[] returns a reference

Let’s take a closer look at how list[2] = 3 evaluates. Because the subscript operator has a higher precedence than the assignment operator, list[2] evaluates first. list[2] calls operator[], which we’ve defined to return a reference to list.m_list[2]. Because operator[] is returning a reference, it returns the actual list.m_list[2] array element. Our partially evaluated expression becomes list.m_list[2] = 3, which is a straightforward integer assignment.

In lesson 1.3 -- Introduction to objects and variables, you learned that any value on the left hand side of an assignment statement must be an l-value (which is a variable that has an actual memory address). Because the result of operator[] can be used on the left hand side of an assignment (e.g. list[2] = 3), the return value of operator[] must be an l-value. As it turns out, references are always l-values, because you can only take a reference of variables that have memory addresses. So by returning a reference, the compiler is satisfied that we are returning an l-value.

Consider what would happen if operator[] returned an integer by value instead of by reference. list[2] would call operator[], which would return the value of list.m_list[2]. For example, if m_list[2] had the value of 6, operator[] would return the value 6. list[2] = 3 would partially evaluate to 6 = 3, which makes no sense! If you try to do this, the C++ compiler will complain:

C:VCProjectsTest.cpp(386) : error C2106: '=' : left operand must be l-value

Dealing with const objects

In the above IntList example, operator[] is non-const, and we can use it as an l-value to change the state of non-const objects. However, what if our IntList object was const? In this case, we wouldn’t be able to call the non-const version of operator[] because that would allow us to potentially change the state of a const object.

The good news is that we can define a non-const and a const version of operator[] separately. The non-const version will be used with non-const objects, and the const version with const-objects.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

#include <iostream>   class IntList { private:     int m_list[10]{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // give this class some initial state for this example   public:     int& operator[] (int index);     const int& operator[] (int index) const; };   int& IntList::operator[] (int index) // for non-const objects: can be used for assignment {     return m_list[index]; }   const int& IntList::operator[] (int index) const // for const objects: can only be used for access {     return m_list[index]; }   int main() {     IntList list{};     list[2] = 3; // okay: calls non-const version of operator[]     std::cout << list[2] << '\n';       const IntList clist{};     clist[2] = 3; // compile error: calls const version of operator[], which returns a const reference.  Cannot assign to this.     std::cout << clist[2] << '\n';       return 0; }

If we comment out the line clist[2] = 3, the above program compiles and executes as expected.

Error checking

One other advantage of overloading the subscript operator is that we can make it safer than accessing arrays directly. Normally, when accessing arrays, the subscript operator does not check whether the index is valid. For example, the compiler will not complain about the following code:

1 2	int list[5]{}; list[7] = 3; // index 7 is out of bounds!

However, if we know the size of our array, we can make our overloaded subscript operator check to ensure the index is within bounds:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#include <cassert> // for assert()   class IntList { private:     int m_list[10]{};   public:     int& operator[] (int index); };   int& IntList::operator[] (int index) {     assert(index >= 0 && index < 10);       return m_list[index]; }

In the above example, we have used the assert() function (included in the cassert header) to make sure our index is valid. If the expression inside the assert evaluates to false (which means the user passed in an invalid index), the program will terminate with an error message, which is much better than the alternative (corrupting memory). This is probably the most common method of doing error checking of this sort.

Pointers to objects and overloaded operator[] don’t mix

If you try to call operator[] on a pointer to an object, C++ will assume you’re trying to index an array of objects of that type.

Consider the following example:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

#include <cassert> // for assert()   class IntList { private:     int m_list[10]{};   public:     int& operator[] (int index); };   int& IntList::operator[] (int index) {     assert(index >= 0 && index < 10);       return m_list[index]; }   int main() {     IntList *list{ new IntList{} };     list [2] = 3; // error: this will assume we're accessing index 2 of an array of IntLists     delete list;       return 0; }

Because we can’t assign an integer to an IntList, this won’t compile. However, if assigning an integer was valid, this would compile and run, with undefined results.

Rule

Make sure you’re not trying to call an overloaded operator[] on a pointer to an object.

The proper syntax would be to dereference the pointer first (making sure to use parenthesis since operator[] has higher precedence than operator*), then call operator[]:

1 2 3 4 5 6 7 8

int main() {     IntList *list{ new IntList{} };     (*list)[2] = 3; // get our IntList object, then call overloaded operator[]     delete list;       return 0; }

This is ugly and error prone. Better yet, don’t set pointers to your objects if you don’t have to.

The function parameter does not need to be an integer

As mentioned above, C++ passes what the user types between the hard braces as an argument to the overloaded function. In most cases, this will be an integer value. However, this is not required -- and in fact, you can define that your overloaded operator[] take a value of any type you desire. You could define your overloaded operator[] to take a double, a std::string, or whatever else you like.

As a ridiculous example, just so you can see that it works:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

#include <iostream> #include <string>   class Stupid { private:   public: void operator[] (const std::string& index); };   // It doesn't make sense to overload operator[] to print something // but it is the easiest way to show that the function parameter can be a non-integer void Stupid::operator[] (const std::string& index) { std::cout << index; }   int main() { Stupid stupid{}; stupid["Hello, world!"];   return 0; }

As you would expect, this prints:

Hello, world!

Overloading operator[] to take a std::string parameter can be useful when writing certain kinds of classes, such as those that use words as indices.

Conclusion

The subscript operator is typically overloaded to provide direct access to individual elements from an array (or other similar structure) contained within a class. Because strings are often implemented as arrays of characters, operator[] is often implemented in string classes to allow the user to access a single character of the string.

Quiz time

Question #1

A map is a class that stores elements as a key-value pair. The key must be unique, and is used to access the associated pair. In this quiz, we’re going to write an application that lets us assign grades to students by name, using a simple map class. The student’s name will be the key, and the grade (as a char) will be the value.

a) First, write a struct named StudentGrade that contains the student’s name (as a std::string) and grade (as a char).

Show Solution

1 2 3 4 5 6 7

#include <string>   struct StudentGrade {     std::string name{};     char grade{}; };

b) Add a class named GradeMap that contains a std::vector of StudentGrade named m_map.

Show Solution

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include <string> #include <vector>   struct StudentGrade { std::string name{}; char grade{}; };   class GradeMap { private: std::vector<StudentGrade> m_map{}; };

c) Write an overloaded operator[] for this class. This function should take a std::string parameter, and return a reference to a char. In the body of the function, first see if the student’s name already exists (You can use std::find_if from <algorithm>). If the student exists, return a reference to the grade and you’re done. Otherwise, use the std::vector::push_back() function to add a StudentGrade for this new student. When you do this, std::vector will add a copy of your StudentGrade to itself (resizing if needed, invalidating all previously returned references). Finally, we need to return a reference to the grade for the student we just added to the std::vector. We can access the student we just added using the std::vector::back() function.

The following program should run:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

#include <iostream>   // ...   int main() { GradeMap grades{};   grades["Joe"] = 'A'; grades["Frank"] = 'B';   std::cout << "Joe has a grade of " << grades["Joe"] << '\n'; std::cout << "Frank has a grade of " << grades["Frank"] << '\n';   return 0; }

Show Solution

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

#include <algorithm> #include <iostream> #include <string> #include <vector>   struct StudentGrade { std::string name{}; char grade{}; };   class GradeMap { private: std::vector<StudentGrade> m_map{};   public: char& operator[](const std::string &name); };   char& GradeMap::operator[](const std::string &name) { auto found{ std::find_if(m_map.begin(), m_map.end(), [&](const auto& student){    return (student.name == name); }) }; if (found != m_map.end()) { return found->grade; }   // otherwise create a new StudentGrade for this student and add // it to the end of our vector. m_map.push_back({ name });   // and return the element return m_map.back().grade; }   int main() { GradeMap grades{};   grades["Joe"] = 'A'; grades["Frank"] = 'B';   std::cout << "Joe has a grade of " << grades["Joe"] << '\n'; std::cout << "Frank has a grade of " << grades["Frank"] << '\n';   return 0; }

Tip

Since maps are common, the standard library offers std::map, which is not currently covered on learncpp. Using std::map, we can simplify our code to

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#include <iostream> #include <map> // std::map #include <string>   int main() { // std::map can be initialized std::map<std::string, char> grades{ { "Joe", 'A' }, { "Frank", 'B' } };   // and assigned grades["Susan"] = 'C'; grades["Tom"] = 'D';   std::cout << "Joe has a grade of " << grades["Joe"] << '\n'; std::cout << "Frank has a grade of " << grades["Frank"] << '\n';   return 0; }

Prefer using std::map over writing your own implementation.

Question #2

Extra credit #1: The GradeMap class and sample program we wrote is inefficient for many reasons. Describe one way that the GradeMap class could be improved.

Show Solution

std::vector is unsorted by nature. This means every time we call operator[], we’re potentially traversing the entire std::vector to find our element. With a few elements, this isn’t a problem, but as we continue to add names, this will become increasingly slow. We could optimize this by keeping our m_map sorted and using a binary search, so we minimize the number of elements we have to look through to find the ones we’re interested in.

Question #3

Extra credit #2: Why doesn’t this program work as expected?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#include <iostream>   int main() { GradeMap grades{};   char& gradeJoe{ grades["Joe"] }; // does a push_back gradeJoe = 'A';   char& gradeFrank{ grades["Frank"] }; // does a push_back gradeFrank = 'B';   std::cout << "Joe has a grade of " << gradeJoe << '\n'; std::cout << "Frank has a grade of " << gradeFrank << '\n';   return 0; }

Show Solution

When Frank is added, the std::vector must grow to hold it. This requires dynamically allocating a new block of memory, copying the elements in the array to that new block, and deleting the old block. When this happens, any references to existing elements in the std::vector are invalidated! In other words, after we push_back("Frank"), gradeJoe is left as a dangling reference to deleted memory. This will lead to undefined results.

13.10 -- Overloading the parenthesis operator

Index

13.8 -- Overloading the increment and decrement operators

C++ Tutorial |  Print This Post

260 comments to 13.9 — Overloading the subscript operator

• Kacper Bazan

  June 16, 2021 at 7:01 am · Reply

  Should we be using std::size_t instead of int for the parameters that deal with indexing our array?

• Haldhar Patel

  June 8, 2021 at 10:40 pm · Reply

  So every time we push_back() an element to the vector it needs to grow to hold that element and also deallocate the previous block of memory, this seems so time taking and also we may face the problem of dangling reference.

  >So tell me if the following is wrong-->
  But if we know how much elements we need , we must allocate that much of memory before any push_back() operations and then the vector won't need to grow every time we add elements to it and hence will not reallocate every time also we will not have problems of dangling reference{given that we are not increasing our number of elements more than the size of the vector}

  >and hence I try something like this
  instead of

  1	std::vector<StudentGrade> m_map{};

  I write

  1	std::vector<StudentGrade> m_map(10){};

  then there are lot of errors in the solution of que(1.c), most of them are

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  C:\Users\User\Desktop\sublime\reply.cpp:15:37: error: expected identifier before numeric constant //    15 |     std::vector<StudentGrade> m_map(10){}; //       |                                     ^~ // C:\Users\User\Desktop\sublime\reply.cpp:15:37: error: expected ',' or '...' before numeric constant // C:\Users\User\Desktop\sublime\reply.cpp: In member function 'std::vector<StudentGrade> GradeMap::m_map(int)': // C:\Users\User\Desktop\sublime\reply.cpp:15:41: warning: no return statement in function returning non-void [-Wreturn-type] //    15 |     std::vector<StudentGrade> m_map(10){}; //       |                                         ^ // C:\Users\User\Desktop\sublime\reply.cpp: In member function 'char& GradeMap::operator[](const string&)': // C:\Users\User\Desktop\sublime\reply.cpp:23:30: error: invalid use of member 'std::vector<StudentGrade> GradeMap::m_map(int)' (did you forget the '&' ?) //    23 |     auto found{ std::find_if(m_map.begin(), m_map.end(), //       |                              ^~~~~ // C:\Users\User\Desktop\sublime\reply.cpp:23:45: error: invalid use of member 'std::vector<StudentGrade> GradeMap::m_map(int)' (did you forget the '&' ?) //    23 |     auto found{ std::find_if(m_map.begin(), m_map.end(), //       |                                             ^~~~~ // C:\Users\User\Desktop\sublime\reply.cpp:26:20: error: unable to deduce 'auto' from '<expression error>' //    26 |                 }) }; //       |                    ^

  >I don't know what is happening but I think-- Although we are giving a size of 10 to the vector , the push_back operation will always increase one size of the vector{as all the 10 places in the vector might have already filled with the default value} and hence it will reallocate this time too, and we will face the dangling reference problem again, but I thought it will run at least but I get the errors which I don't know why. Can you tell me what is happening here?

  >I think the problem can be solved in two ways here
  1.first if we make a counter variable and then override the default elements values every time we get a different name or override the grade if we get the same name{I don't know if this is possible I haven't tried}

  2.Instead of making a vector of 10 size , if we reserve{through m_map.reserve(10)} that much of size then we will not have a default value for each of them , then push_back will also not reallocate every time{Again I haven't tried}

  Maybe if you can show me how we can write the above program if we know the size of the vector before the operations on it or why I am getting those errors I will be very grateful to you.
  Thanks

  • Alex

    June 10, 2021 at 11:08 am · Reply

    Try:

    1	std::vector<StudentGrade> m_map(10);

    Also when a vector resizes, it typically resizes in a way that leaves room for extra elements to be added before another resize needs to take place.

• Mark

  May 25, 2021 at 12:48 am · Reply

  Just a question out of curiosity, how does c++ know that our argument for using '[]' is between the brackets?
  For example when overloading the '<<' operator the argument comes after the '<<', so why doesn't c++ think we will use the [] operator in the same way? I.e. if we would want index 2 of some array, why doesn't c++ expect us to do so by 'array[]2'?

  • Alex

    May 26, 2021 at 9:42 am · Reply

    Parenthesis (), hard braces [], and curly braces {} are all defined to have the values in-between. So when the compiler is parsing these expressions, the parsing rules are set up in such a way to expect this.

• bob loblaw

  April 12, 2021 at 6:06 am · Reply

  Hi, I tried doing question 1 without using findif like so:

  1 2 3 4 5 6 7 8 9

  for (StudentGrade student : m_map)     {         if (student.name == name)         {             std::cout << student.grade << '\n';             return student.grade;         }     }

  I used the debugger and that std::cout prints the correct thing ('A', then 'B') and when I check the value of student.grade in the debugger it is what I expect (char 'A' and 'B'), but then for the return when that is printed out it prints a weird non-ascii character.  When I use the solution provided the return works even though (as far as I can tell) the type is the same.  I'm not sure why this is happening, can I get a pointer, please?

  • nascardriver

    April 15, 2021 at 7:39 am · Reply

    Your loop variable `student` is a copy of each map element. Your function returns a reference, but `student.grade` is a local variable, which dangles when you return it.

    • bob loblaw

      April 15, 2021 at 8:06 am · Reply

      Ah, that makes sense, thank you!
      Additionally, thank you so so much for the website as a whole!

• JustAPleb

  March 3, 2021 at 12:13 pm · Reply

  Hi, i feel like this chapter should also covert what happens when you overload the operator[] with array's of object. Tho if i understood everything up to this point. it's like 2D array for the first [] for the array of object and the second[] operator for the inner array's.

• Aphamino

  February 22, 2021 at 4:13 pm · Reply

  Hi!

  In the given solution for question #3 it says that "This requires dynamically allocating a new block of memory...". I thought that vectors handle their own memory management (isn't is a vector into which we are storing the (name, grade) pairs?

  • nascardriver

    February 23, 2021 at 8:17 am · Reply

    Hi

    Vectors handle their own memory, they use dynamic memory allocation

• Rostyslav

  February 19, 2021 at 7:27 am · Reply

  Very nice that you introduce routines from <algorithm> in the quiz tasks.

• yeokaiwei

  December 17, 2020 at 6:16 am · Reply

  1. Feedback

  1 2	int list[5]{}; list[7] = 3; // index 7 is out of bounds!

  Microsoft Visual Studio 2019 will return 2 warnings.
  C6201 'Index 7 is out of range' and C6386 'Buffer overrun'

• CC

  October 3, 2020 at 7:00 am · Reply

  In your example of overloading `operator[]` to take string indices (and, indeed, in pretty much every other example prior where you overload an operator using member functions), you declare the overloaded operator within the class but implement it outside the class.

  Is there any particular reason why you do this? I tried to see what would happen if I define the overloaded operator within the class (specifically for your string indexing example) and it worked, but I'm not sure if there's a reason not to do it that way in the first place.

  • nascardriver

    October 10, 2020 at 2:10 am · Reply

    There's no point in doing so in this example. In practice, classes get separated into header and source file, so there'll rarely be function definitions in the class definition.

• Eric

  August 31, 2020 at 12:39 pm · Reply

  In reference to quiz 1.c can you clarify what's happening here?:

  1	m_map.push_back({ name }); //name is reference to StudentGrade.name and is a string

  can we push_back a just one element of struct StudentGrade (the string element) and create a whole new StudentGrade array element (with its corresponding grade structure element) automatically? I thought we'd have to push_back the entire structure element like "push_back(student)".
  Thanks for clarifying.
  Cheers!

  • nascardriver

    September 1, 2020 at 12:36 am · Reply

    We can construct a student by using only a part of its members

    1	Student eric{ "eric" }; // grade is initialized with the value given in the struct definition

    The same is happening when we use list initialization in any other place

    1 2 3 4

    Student fn() {   return { "eric" }; }

• Michael

  August 31, 2020 at 11:08 am · Reply

  Hi there!

  I am trying to overload the subscript operator in a templated Array class that I created but I am getting a linker error. I am able to get it to work if I define the function inside the class but it doesn't work when I move it to the Array.cpp file.

  Below is all the code I have so far:

  Array.h

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

  //#pragma once   #include <cassert> #include <iostream>   #ifndef CUSTOMARRAY #define CUSTOMARRAY   template <typename T> class Array {     T *m_array;     int m_size;   public:       Array(int size)     {         std::cout << "In Array constructor.\n";           assert(size > 0);         m_array = new T[size]{};         m_size = size;     }       int size() const { return m_size; }       T& operator[](int index); // Inline definition works, commented out as I don't want it located here     /*{         assert(index >= 0 && index < m_size);           return m_array[index];     }*/       friend std::ostream& operator<<(std::ostream &out, const Array<T> &array)     {         for (int i{ 0 }; i < array.size(); ++i)         {             out << array.m_array[i] << " ";         }           return out;     } };   #endif

  Array.cpp

  1 2 3 4 5 6 7 8 9

  #include "Array.h"   template<typename T> T& Array<T>::operator[](int index) // This doesn't work as expected {     assert(index >= 0 && index < m_size);       return m_array[index]; }

  CustomArray.cpp (main project file)

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  // CustomArray.cpp : This file contains the 'main' function. Program execution begins and ends there. // #include "Array.h"   #include <iostream>   int main() {     Array<int> arr{5};       std::cout << arr << '\n'; // This line works as expected     std::cout << arr[0] << '\n'; // This line does not work     return 0; }

  Error received: LNK2019    unresolved external symbol "public: int & __cdecl Array<int>::operator[](int)" ([email protected]@@[email protected]) referenced in function main

  • nascardriver

    September 1, 2020 at 12:28 am · Reply

    You can't define template functions in source files with their declaration being in the header unless you explicitly instantiate them, which defeats the purpose of using a template. Define the functions in the header.

    • Michael

      September 1, 2020 at 7:54 am · Reply

      Perfect, thank you! Should have looked more closely at the template section I guess :P