access the entire column of a 2D matrix implemented using std::vector

Question

Is it possible to get an entire column of a 2D matrix which is implemented as std::vector<std::vector<int32_t>>. We all know we can access an entire row using range for loop like for(const auto& row : matrix). Is there a similar way to access an entire column using range for loop like for(const auto& col : matrix)

Answer 1

It is possible using range based for loops, to access the column values, you just have a fixed index:

 for(const auto& row : matrix) {
      cout << row[5] << endl; // 5 is the fixed column index
 }

From knowing that it's possible to write a little helper function which extracts a complete column into another std::vector<>:

 std::vector<int> extract_column(const std::vector<std::vector<int>>& matrix, int col_idx) {
      std::vector<int> result;
      for(const auto& row : matrix) {
          result.push_back(row[col_idx]);
 }

Here's a complete example:

#include <iostream>
#include <vector>


 std::vector<int> extract_column(const std::vector<std::vector<int>>& matrix, int col_idx) {
      std::vector<int> result;
      for(const auto& row : matrix) {
          result.push_back(row[col_idx]);
      }
      return result;
 }

int main() {
    std::vector<std::vector<int>> matrix = 
        { { 1, 2, 3 } ,
          { 4, 5, 6 } ,
          { 7, 8, 9 }
        };

    // print the middle row
    for(auto elem : extract_column(matrix,1)) {
        std::cout << elem << std::endl;
    }
}

Output

2
5
8

See the online demo

---

That said, it should be noted that a std::vector<std::vector<T>> as solution for a matrix representation is suboptimal.

The better fit would be to represent all the matrix elements (for arbitrary dimensions) as a contiguous array, and apply some basic math, to access certain (groups) of matrix elements. The std::vector<std::vector<T>> uses separate allocations for the row elements

To illustrate:

      +-+-+-+
row 1 |1|2|3|
      +-+-+-+
      +-+-+-+    +-+-+-++-+-+-++-+-+-+
row 2 |4|5|6| => |1|2|3||4|5|6||7|8|9|
      +-+-+-+    +-+-+-++-+-+-++-+-+-+
      +-+-+-+
row 3 |7|8|9|     row 1  row 2  row 3
      +-+-+-+

But how to this exactly would lead too far here, and was already answered in other questions at SO, and realized by a number of math frameworks.

Answer 2

While I see no way to do this with the actual std::vector, what you could do would be to implement your own class Matrix which stores a 2D vector (or which even inherits from one, which I don't recommend though - especially I'd make sure that my matrix class never contains a jagged array).
If you have done that, you could then create another class Column, which looks somewhat like this:

class Column
{
    private:
        Matrix* target; // << consider rather using smart pointers here
        size_t column_index;
    public:
        int32_t& operator[](size_t index)             { return (*target)[column_index][index]; }
        const int32_t& operator[](size_t index) const { return (*target)[column_index][index];  }
};

So far so good, you now have a column class that accesses some matrix. Simplest approach would now be to also have some method for the size (that again accesses the matrix class) and then do a old fashioned for loop, for(size_t i=0; i<size; i++)...

If you now want a range based loop instead, what you'd have to do is to give Column an inner class Iterator that behaves as iterator and give Column two methods begin() and end() which each return a fitting Iterator.

class Column
{
    ...
    public:
     ...

        size_t size(); // I omit the details here

        class Iterator
        {
            ...
        };
    
        Iterator begin() { return Iterator(this, 0); }
        Iterator end()   { return Iterator(this, size()); }
};

This would be the base structure of such an iterator being used. Note that you'd had to actually write two such classes, one being constant.
Inside the iterator would look somewhat like this:

class Column::Iterator
{
    private:
        Column* father;
        size_t index;
    public:
        Iterator(Column* father, size_t index) : father(father), index(index { }
        Iterator operator++()    { Iterator i = *this; i.index++; return i; }
        Iterator operator++(int) { index++; return *this; }
        int32_t& operator*()     { return (*father)[index]; }
        int32_t* operator->()    { return &((*father)[index]); }
        bool operator==(const Iterator& other) { return father == other.father and index == other.index; }
        bool operator!=(const Iterator& other) { return not operator==(other); }
};

Note that I haven't tested the code.

More on this topic:

How to make the for each loop function in C++ work with a custom class https://codereview.stackexchange.com/questions/74609/custom-iterator-for-a-linked-list-class https://gist.github.com/jeetsukumaran/307264

Answer 3

You need a column access facet. Your facet will have:

1. a reference to the matrix, e.g. m_matrix
2. the column number, e.g. m_column

You specify the matrix and the column number to construct the facet. Then you need to define operator[] (row) { return this ->m_vector [row] [this ->m_column]; }. HTH.