How to use algorithms to fill vector of vectors

Question

I have

typedef std::vector<int> IVec;
typedef std::vector<IVec> IMat;

and I would like to know how I can fill an IMat by using std algorithms, ie how to do the following with less code (all the IVecs have the same size) ?

void fill(IMat& mat){
    for (int i=0;i<mat.size();i++){
        for (int j=0;j<mat[i].size();j++){
            mat[i][j] = i*j;
        }
    }
}

PS: already a way to fill the matrix with a constant would help me. And preferably with pre-C++11 algorithms.

Answer 1

The best solution is the one that you have already implemented. It takes advantage of using i/j as both offsets and as inputs to compute the algorithm.

Standard algorithms will have to use iterators for the elements and maintain counters. This data mirroring as a sure sign of a problem. But it can be done, even on one line if you wanna be fancy:

for_each(mat.begin(), mat.end(), [&](auto& i) { static auto row = 0; auto column = 0; generate(i.begin(), i.end(), [&]() { return row * column++; }); ++row; });

But as stated just cause it could be done doesn't mean that it should be done. The best way to approach this is the for-loop. Even doing it on one line is possible if that's your thing:

for(auto i = 0U;i < mat.size();i++) for(auto j = 0U;j < mat[i].size();j++) mat[i][j] = i*j;

---

Incidentally my standard algorithm works fine on Clang 3.7.0, gcc 5.1, and on Visual Studio 2015. However previously I used transform rather than generate. And there seem to be some implementation bugs in gcc 5.1 and Visual Studio 2015 with the captures of lambda scope static variables.

Answer 2

I don't know if this is better than a double for loop, but one possible way you could do it using STL in C++11 would be using two for_each as follows:

int i(0);
std::for_each(mat.begin(), mat.end(),
[&i](IVec &ivec){int j(0); std::for_each(ivec.begin(), ivec.end(), 
                           [&i,&j](auto &k){k = i*j++;}); ++i;});

LIVE DEMO

Answer 3

Just thought I'd comment further on Jonathan's excellent answer.

Ignore the c++11 syntax for now and imagine that we had written some supporting classes (doesn't matter how for now).

we could conceivably come up with code like this:

auto main() -> int
{
    // define a matrix (vector of vectors)
    IMat mat;

    // resize it through some previously defined function
    resize(mat, 10, 10);

    // get an object that is a pseudo-container representing its extent
    auto extent = extent_of(mat);

    // generate values in the pseudo-container which forwards to the matrix
    std::generate(extent.begin(), 
                  extent.end(), 
                  [](auto pxy) { pxy.set_value(pxy.x * pxy.y); });

    // or even

    for (auto pxy : extent_of(mat)) {
        pxy.set_value(product(pxy.coordinates()));
    }

    return 0;
}

100 lines of supporting code later (iterable containers and their proxies are not trivial) and this would compile and work.

Clever as it undoubtedly would be, there are some problems:

• There's the small matter of the 100 extra lines of code.
• It seems to me that this code is actually less expressive than yours. i.e. it's immediately obvious what your code is doing. With mine you have to make some assumptions or go and reason about the extra 100 lines of code.
• my code needs a lot more maintenance (and documentation) than yours

Sometimes less is more.