objects' variables get reset in vector (casting from void*) - c++

Question

Some background:
I am using Box2D in a game I'm making. It has a way of storing "user-data" to Box2D objects. This "user-data" takes a void*, so that it can be used for storing user-defined data. Now, when Box2D collisions happen, you can use this "user-data" to identify which objects have collided. Then you can cast the data to a class, and access the functions or variables of that class (and the particular instance of that class, if you have set the "user-data" as a reference to that instance). I have two sets of "user-data", one is a reference to a class instance and another to a struct so I can check the type of the objects.
This works good for objects that are not in a vector. I have tested this, and I can access the functions and variables(and modify them) of class instances without them being reset. But when I access my std::vector< Tile> objects by casting from void*, the variables I modify get reset immediately.
Relevant code:
I set the "user-data" like this:
tile->SetUserData(static_cast<Entity*>(this));
ball->SetUserData(static_cast<Entity*>(this));
bUserData* bud = new bUserData;
bud->entityType = BALL;
ballFixture.userData = bud;
bUserData* bud = new bUserData;
bud->entityType = TILE;
tileFixture.userData = bud;
MyContactListener class keeps track when the collisions start and end, this is also where the casting from void* to foo* happens:
MyContactListener.cpp
std::vector<Tile> solidTiles;
Ball ball;
// Called when two objects begin to touch.
void MyContactListener::BeginContact(b2Contact* contact) {
// Cast from void* to a struct, from which I can check the object type.
bUserData* budA = (bUserData*)contact->GetFixtureA()->GetUserData();
bUserData* budB = (bUserData*)contact->GetFixtureB()->GetUserData();
// Cast from void* UserData to Entity* (super-class of all the entities).
Entity* entityA = (Entity*)contact->GetFixtureA()->GetBody()->GetUserData();
Entity* entityB = (Entity*)contact->GetFixtureB()->GetBody()->GetUserData();
if((budA->entityType == TILE && budB->entityType == BALL)) {
Tile* tile = (Tile*)entityA; // Tiles are in std::vector<Tile>
Ball* ball = (Ball*)entityB; // Only one ball instance exists
// Modifying a tile instance variable, gets reset to the original value immediately!
tile->flaggedToErase = true;
// This works fine!
ball->setColorToBlue = true;
}
}
Question: How do I keep variables of the tile instances in vector from being reset to their original value?

Answer 1

Is it supposed to be a vector of Tile or Tile*? At a guess, I would suspect that this problem is due to using vector<Tile> which stores a copy of the object, as opposed to vector<Tile*> which stores a pointer to the object.
Compare this:
std::vector< Tile > tiles;
Tile t;
t.foo = 123;
tiles.push_back( t ); // a copy of t is put into the vector
t.foo = 456; // changes t, but not the copy in the vector
Tile t2 = tiles[0]; // makes yet another copy (t2.foo == 123)
... with this:
std::vector< Tile* > tiles;
Tile* t = new Tile;
t->foo = 123;
tiles.push_back( t ); // a pointer is put into the vector
t->foo = 456; // also changes in the vector because it's the same thing
Tile* t2 = tiles[0]; // still the same thing (t2->foo == 456)
If you want to have a vector of objects (not pointers) and change them inside the vector, you can do it like this:
std::vector< Tile > tiles;
Tile& t = tiles[0]; // note the ampersand, accesses by reference
t.foo = 456; // changes inside the vector
// I think you can also do this
tiles[0].foo = 456;
However, to do this you need to have the vector itself available, and you need to know which position the element you want to change is at. For your case, you don't know which position the element is at within the vector, so using vector<Tile*> is the simplest solution.