Question

In my question a vector means a vector of structures of the form

struct node 
      {string key; 
       int a,b; };

I want to code up the following: Given a user specified number say d I want to create a sequence of d vectors v_1, v_2, ...v_d.

v_1 is created from user data, and v_i from v_(i-1) for i>=2 .
The size of v_i is the number of nodes in v_(i-1) with distinct key fields.
The a and b fields of the v_i nodes are calculated according to some black box algorithm from those of v(i-1)

How should I code this up efficiently in C++?
Should I use a map of the form
map<int, vector<nodes>> where the int field varies between 1 and d??

Thank you!

P:S: I guess one could code up a solution, using new operator and some pointer gymnastics, instead of using vectors. But I would like to have as pointer free a solution as possible.

Answer 1

Use std::vector<std::vector<node> >, but use vector::reserve() intelligently so as to avoid reallocations:

using std::vector;
vector<vector<node>> v(d); // 0 nodes allocated, no wasted space yet

using std::copy;
using std::istream_iterator;
using std::back_inserter;
// Wish I could v[0].reserve(), but we don't have that info yet.
copy(istream_iterator<node>(std::cin), istream_iterator<node>(), back_inserter(v[0]));

// foreach v[1..d-1], compute v[i] from v[i-1]
for(int i = 1; i < d; ++i) {
    int size = ComputeSize(v[i-1]); // how big a list do we need?
    v[i].reserve(size);  // reserve the space for it, and 
    PopulateVectorFromVector(v[i-1], v[i]); // fill it in.
}

The only vector with wasted space and time is v[0].

---

EDIT: the call to std::copy above is a loop-less idiom roughly equivalent to

node tmp;
while(std::cin >> tmp) {
    v[0].push_back(tmp);
}

std::copy takes three arguments. The first two are input iterators which define the range from which we copy, while the third is an output iterator defining the destination.

Specifically, istream_iterator<node>(std::cin) is an input iterator which, when dereferenced, reads the next node from the standard input stream. back_inserter(v[0]) is an output iterator which, when dereferenced and assigned to, invokes v[0].push_back().