Well, I am writing a code to perform a 2D random walk: there are sites

struct Site {
index;
species;
}

and a lattice

class Lattice {
public:
// ctor, dtor, functions, methods, blah blah blah
int randomWalk(const int position);
private:
// more stuff
vector<Site> _sites;
}

the idea is to move a species from _sites.at(0) to _sites.at(1), like
randomWalk(pos) {_sites.at(pos+1).species = _sites.at(pos).species; _sites.at(pos).species = 0; return pos+1;}
but it is a bit more complicated so I would like to do something similar to
... { Site origin = _sites.at(pos); Site destination = _sites.at(pos+1); // the rest }
this obviously does not work because the species is moved on the copies and not on the lattice.

On the first version, I was using a vector of pointers to "Site"s
vector<Site*> _sites;
and it was working because I was not making a copy but using the address of a site really into the lattice.

Now, I can make it work if I update the lattice, since the copies have the correct index.

So it is not like I cannot fix it.

BUT, the question is, is there an elegant way to do what I want, without making unnecessary copies and using a vector of objects instead of a vector of pointers?

Note that this is a *random* walk, so the destination is actually not at pos+1, but needs to be calculated in the real program. And I have boundary conditions, so the arrival can be at pos+(x dimension of the lattice) - (size of the lattice) or any non trivial shift from the origin.

I'd really appreciate a nice solution before I go back to the vector of pointers...

to me a vector of pointers is superior to a vector of objects, assuming they are of significant size.

If you have the boost libraries, using a boost::shared_ptr is perfect for stuff like this.


typedef boost::shared_ptr<Site> SitePtr;


Then make your vector:

vector<SitePtr> _sites;


Now it will work the same as a vector<Site *>, but you don't have to worry about deleting the pointers when you are done with them, and boost::shared_ptr is safe to use in containers unlike auto_ptr.

Just the shared_ptr object get copied. They use reference counting to know when they are no longer used, and delete the objects.

Thank you for your answers, so I will go back to the vector of pointers, then. I'll have a look at boost::shared_ptr too but in principle, the size should not change. And yes, the size will be significant, like 128*128 or 256*256, maybe.