STL Vector question

[Beamu]

Hi all,

Just having a semantics issue with STL. Given a declaration as per the following:

	typedef std::vector <int> fooData;
	std::vector <fooData> m_fooData;

I can access the data by using the following code:

        m_fooData[0][0];

However I can't get my head around how I access the data in the following scenario (or if it's even valid):

	typedef std::vector <int> fooData;
	std::vector <fooData *> m_fooData;

Can anyone point out what i'm misunderstanding?

Cheers!

[matsp]

(*m_foodata[0])[0]

I think.

Storing a pointer to a vector seems a bit useless to me - unless you have a scenario where you have a large existing vector (or a large number of existing vectors) that you need to insert into a class - but that seems a bit bass ackwards too.

--
Mats

[Beamu]

Yeah - maybe i'm going about this wrong...

What i'm trying to do is store a vector of vectors of type int. Which is fine, given this scenario:

	typedef std::vector <int> fooData;
	std::vector <fooData> m_fooData;

However, I don't know how many "fooData"'s there is going to be until runtime. So in that case how would I populate my vector of ints, then push_back that vector to the vector vectors? Is this valid?

      fooData temp;

      while (...) 
      {
           x = "some calculation";

           temp.push_back(x);
           m_fooData.push_back(temp);
           temp.clear();
      }

[laserlight]

Moved to C++ Programming.

However, I don't know how many "fooData"'s there is going to be until runtime. So in that case how would I populate my vector of ints, then push_back that vector to the vector vectors? Is this valid?

Well... the idea is on the right track, but the code certainly is not valid. What is suspect in your idea is that you push to the back of temp on each iteration of the loop, and also push temp to the back of m_fooData on each iteration.

What you probably want to do is to have nested loops. In the outer loop, you create a new fooData object named temp and then run the inner loop. In the inner loop, you perform the calculation and then push the int result to the back of temp on each iteration. Immediately after control leaves the inner loop you push the fooData object to the back of m_fooData, and only then do you end the current iteration of the outer loop.

[Beamu]

Yup - thanks, you're right there - that was pretty poor pseudo code. But the concept is sound. Is that because the value of temp is copied during the push_back call?

[laserlight]

Yup - thanks, you're right there - that was pretty poor pseudo code.

Besides the obvious syntax errors and the potential problem with your idea as expressed in the code that I pointed out, note that it would be better to create temp in the loop so as to follow the principle of declaring variables near first use. This would also make the use of the clear() member function unnecessary.

But the concept is sound. Is that because the value of temp is copied during the push_back call?

Yes, copying happens with push_back(), but I am not sure how you relate that to the soundness of the concept. The soundness of the concept is due to to use of push_back() to dynamically insert an element at runtime.

[Beamu]

Besides the obvious syntax errors and the potential problem with your idea as expressed in the code that I pointed out, note that it would be better to create temp in the loop so as to follow the principle of declaring variables near first use. This would also make the use of the clear() member function unnecessary.

Yup agreed. Assume I understood what you said, and that my original pseudo code was just plain terrible.

Yes, copying happens with push_back(), but I am not sure how you relate that to the soundness of the concept. The soundness of the concept is due to to use of push_back() to dynamically insert an element at runtime.

Soundness in that my original naive concern was that by continually using the same vector to store data then push that back, I would be changing the original vector and thereby corrupting the data. When I wrote the (admittedly misleading pseudo code above) it was because I'd suddenly realised it does nothing of the sort since it is copied by the push_back method.

[CornedBee]

It would actually be better to push_back an empty fooData and then fill the one that's in the outer vector. This avoids the costly copy of the entire vector.

for(outer loop) {
  m_fooDatas.push_back(fooData());
  fooData &cur = m_fooDatas.back();
  for(inner loop) {
    cur.push_back(whatever);
  }
}

[iMalc]

It would actually be better to push_back an empty fooData and then fill the one that's in the outer vector. This avoids the costly copy of the entire vector.

for(outer loop) {
  m_fooDatas.push_back(fooData());
  fooData &cur = m_fooDatas.back();
  for(inner loop) {
    cur.push_back(whatever);
  }
}

Either that, or just swap it in instead:

for(outer loop) {
  fooData cur;
  for(inner loop) {
    cur.push_back(whatever);
  }
  m_fooDatas.push_back(fooData());
  m_fooDatas.back().swap(cur);
}