out of bound check for multidimensional arrays - c++

Question

I am reading a book on Safe C++. Here, the author mentioned how to avoid out of bound array reading. Here, it is mentioned how we can avoid out of bound array reading for multi dimension arrays. Here author used operator() function as shown in following link instead of operator[] and gave following explanation.
https://github.com/vladimir-kushnir/SafeCPlusPlus/blob/master/scpp_matrix.hpp
Note here that to access multidimensional array, we either need to use multiple [] operators, such as matrix[i][j], or a single () operator, such as matrix(i,j).
The first approach can be achieved if we had the [] operator return a T* pointer to the zeroth element of i-th row. However, this denies us the diagnosis of a column index out of bounds, which defeats the purpose of catching bugs at run-time. We could, of course, create some template class that would include a smart reference to a row, return an instance of using the first operator([i]), and then use the bounds check in the second operator ([j]).
My question what does author mean by "create some template class that would include a smart reference to a row, return an instance of using the first operator([i]), and then use the bounds check in the second operator ([j])." ? Request to provide sample code how we can implement above logic in C++?
Thanks for your time and help.

Answer 1

The basic idea looks something like this:
#include <vector>
#include <iostream>
template <class T>
class matrix {
size_t cols;
size_t rows;
std::vector<T> data;
class row_proxy { // This class is the part the question really asked about
size_t row;
matrix &m;
public:
row_proxy(matrix &m, size_t row) : row(row), m(m) {}
T &operator[](size_t col) {
if (row >= m.rows || col >= m.cols) // Note: row & col are indices not array count
throw std::logic_error("Bad index");
return m.data[row * m.cols + col];
}
};
public:
matrix(size_t cols, size_t rows) : rows(rows), cols(cols), data(rows*cols) {}
row_proxy operator[](size_t row) {
return row_proxy(*this, row);
}
};
int main() {
matrix<int> m(3, 3);
for (int i=0; i<3; i++) // fill the matrix with identifiable numbers
for (int j=0; j<3; j++)
m[i][j] = i * 100 + j;
for (int i=0; i<3; i++) { // show the content
for (int j=0; j<3; j++)
std::cout << m[i][j] << "\t";
std::cout << "\n";
}
try { // test the bounds checking.
m[4][1] = 21;
}
catch(std::logic_error &e) {
std::cerr << e.what();
}
return 0;
}
So, when we create a matrix, we save its size in rows and cols. When we use operator[] on the matrix, that doesn't attempt to directly return a reference to an item in the matrix -- rather, it returns an instance of a proxy class that keeps track of the row and the matrix, and provides an operator[] of its own.
So, when you use matrix[a][b], The first one just saves a and matrix into a proxy object. Then the [b] part gets invoked on that proxy object. That checks that both a and b are within the bounds we saved for the matrix, and if so returns a reference to the correct object in the vector. Otherwise, it throws an std::Logic_error (may not be the best choice -- just the first one that occurred to me).
I should add that there are quite a few variations on this general idea. Just for one example, you could specify the size of the array at compile time, but passing the sizes as template parameters. This can have some advantages -- for example, matrix<int, 2, 3> and matrix<int, 3, 2> are entirely different types, so you can't accidentally assign one to the other. It can also have some disadvantages (most obviously, you need to know the size at compile time or it won't work at all).