参考2d向量中的元素（c ++）

Question

I have a class named Spring in a particle system. The constructor looks like:

Spring(Particle& _a, Particle& _b);

And I have a vector of Particles and I use

Spring mySpring = Spring(myParticles.at(j),myParticles.at(j+1));

inside a loop to add a spring force between two particles. Everything works fine so far. However, I want to use a 2d vector of Particles. That is:

Spring mySpring = Spring(myParticles.at(i).at(j),myParticles.at(i).at(j+1));

And I don't get a reference to the particle. In the first example, whenever I change the particle in my spring class, the particle in the vector gets changed. In the second example the changes are only locally. How can I change the particles in the 2D Vector?

EDIT: I try to make some things clear:

I have some particle systems and each of them consists of a number of particles. Each particle should only interact with the other particles that are in the same system as itself. Therefore I have a vector of particle systems with each particle sytem being a vector of particle objects. (That makes the 2d vector). The first dimension (i) is the system, the second (j) the individual particle. The particles in the system interact with each other (collide, avoid, whatever..) and their positions change. And the vector gets "updated". (That is, the reference works).

However, i have a second (1d) vector of spring forces. The spring force too is used to update the positions of the particles. My constructor does the following:

Spring::Spring(Particle& _a, Particle& _b) {
    a=&_a;
    b=&_b; }

With a and b being Particle*. So i store pointers to two particles in the 2d vector. Another function Spring.doSpring() changes the positions of the particles.

a->pos.x=300;

or

a->velocity+=something..

In the first example I posted I used only one particle system and so there was no need for a 2d vector. And everything works fine. The particles in the vector gets updated. But with the second example my program runs but somehow no matter what the doSpring function does, the particles in the 2d vector don't get updated.

Answer 1

One of the most common issues taking references/pointers to elements inside vectors is reallocation. If you push_back, for example, it's possible the vector will exceed its capacity, allocate a new block of memory, copy everything over, then free the old block. If you've taken references or pointers to elements inside the vector, these still point to the old block, now dead memory, and is a serious bug!

So I'm guessing your particle effect keeps adding new particles to your particles vector, which at some point causes the vector to reallocate when it exceeds capacity. The pointers stored by the Spring class aren't updated though, so point to dead memory and have no effect on the actual particle, which got moved somewhere else by the vector.

Don't take a reference or pointer to an element inside a vector. Use a vector of pointers, a list, or some other container which isn't going to shuffle around the memory addresses of actual elements. If you have to, use iterators to elements inside a vector. In debug builds, assuming you've got a checked STL implementation, you'll get a debug alert if you access the element through the iterator after the vector reallocates itself.

Answer 2

What you are doing looks OK - the following code creates a "2D" vector and illustrates that the .at().at() construct does give you a reference:

#include <vector>
#include <iostream>
using namespace std;

int main() {
    vector <vector<int> > vi;
    vi.push_back( vector <int>() );
    vi.at(0).push_back( 42 );
    cout << vi.at(0).at(0) << endl;    // prints 42
    vi.at(0).at(0) = 666;
    cout << vi.at(0).at(0) << endl;    // prints 666
}

Answer 3

I think this series from C++ FAQ Lite should help.

Please don't be confused by "operator overloading" header. You definitely should read 13.10, 13.11 and 13.12 from there.

Answer 4

If I understand correctly you want to create a 2D array of Particles using std::vector ?

If so you can declare it as: std::vector<std::vector<Particle> > . You could then even use [][] nomenclature to access elements. ( Danger Will Robinson! No boundary checking while using this operator )

However if this 2D array will contain mostly zeros then it might be ok to use a map with indices as keys.