c++ reference to a vector issues?

Im having some difficulties开发者_运维技巧 when passing a reference to a vector as an argument. Initially it was a pointer to a vector of pointers, and the functions called would change attributes of whatever obejct was calling it. For example I used:

(*myVector)[i]->myFunction();

and everything worked perfectly. myFunction() would translate whichever object was the current index of myVector.

Now i've changed the vector to hold a set of objects instead of pointers to the objects as it did originally. Instead of passing a pointer to the vector, i pass a reference of it. I access the function as follows:

myVector[i].myFunction();

It compiles, I find that myFunction() no longer has the same results as it did before. I used a breakpoint and saw that it was changing attributes it should have been, however, those changes never made it to the original object. There was no final translation even though the breakpoint showed the origin of myVector[i] being changed.

I've tried passing a pointer to the vector of objects and used:

(*myVector)[i].myFunction();

and the same thing, it compiled but didn't work.

Finally i tried simply passing a reference to the first object in the vector, and of course that worked just fine:

myObject.myFunction();

Is there some inherent thing im missing about references of vectors? Why does a pointer to a vector of pointers work but a reference to a vector of objects doesnt? Shouldn't the passed vector be an alias to the original vector? Why is the reference showing changes but not the object it referenced?

Why wont my changes stick unless i used a vector of pointers instead of a vector of objects.

Hold on a minute. When you changed this snippet:

(*myVector)[i]->myFunction()

To this:

myVector[i].myFunction()

You've actually changed two things:

1. myVector went from pointer to reference;
2. The type of the elements inside myVector went from pointer to simple value type.

If you changed the type of the elements to a simple value type (as in std::vector<int*> to std::vector<int>), then when you add them to your vector, they are copied to it. (The way the vector is passed around, that is, by pointer or by reference, doesn't affect this behavior. The way the vector is passed and the way the objects inside the vector are passed are completely independent.) This mean that whenever you make a change to them, you only change the version that's inside the vector.

There's nothing wrong with using a vector that holds pointers (as long as you do your memory management in a sensible way). If you want the changes to the version you have in your vector to be replicated to the originals, you'll have to use references or pointers. Since it's a world of pain to have a vector contain references (as in std::vector<int&>), if at all possible, you would probably prefer pointers.

If your changes aren't making it into the "original" object it sounds like you passed by value somewhere. Here are some ideas. Perhaps you can post some more code?

1. Did you put copies of the objects into the vector, and expect the originals to be modified?

2. The problem could be that your objects' copy constructor doesn't copy all the members. Is the vector growing? If objects are being moved around inside the vector, it's critical to get the copy constructor working.

Finally:

Keeping a vector full of pointers, or smart pointers that are container safe, is usually a better fit than a vector of objects, because it avoids unnecessary copying and destructing. Unless the objects are very small (like a Date class with one data member) I wouldn't put them into a vector, I'd use smart pointers.

It shouldn't matter here whether you pass a pointer to a vector, or a reference to a vector. Conceptually they are different (references can't be null, for one), but in the implementation they are both pointers to the vector, and the vector isn't passed by value.

The problem has nothing to do with whether you hold a pointer or a reference to the vector. It has to do with what the vector contains. If the vector contains pointers, then when you change the pointed-to objects in the vector, whatever other pointers or references exist for the same objects will be affected as well. But if your vector contains objects (by value), you are copying them when you insert, and changes inside the vector won't be seen outside, nor vice versa.

This is the fundamental nature of pointers and references--if it doesn't make sense, you should look for a decent book on C++.

When a vector stores objects, it stores a copy of the original object that was passed in. So when you do something like this

yourClass yourObj;
std::vector<yourClass> yourVector;
yourvector.push_back(yourObj);
yourvector[0].myFunction();

only the object at yourvector[0] changes because it is a copy of the original.