Question: I store pointers to all instances of class `Cell` in a linked list. The `std::list<Cell*> cells` is stored in a class named `Game`. The method `Game::update()` iterates trought all instances of `Cell` held in the list `cells`, and calls each cell's `Cell::update()` method. If the `Cell::update()` method finds out at some point that the cell is ready to divide, it needs to `push_back()` a pointer to the new cell to `cells` in order for the new cell to be updateable.
But how can I refer to `Game::cells` within the `cell` in order to do that? I have considered the following options:

* Defining `std::list<Cell*> cells` in global scope instead.
	+ nasty and makes it impossible to have more than one `Game`
* Making `std::list<Cell*> cells` a static member of `Cell`
	+ better than the global var but still prevents the use of multiple `Game` instances
* Passing a reference to the current game's `Game::cells` as a parameter to the Cell's constructor and subsequently storing a copy of that reference in the newly constructed cell instance
	+ I think it is a little inflexible
* Passing a reference to the current game's `Game::cells` as a parameter to the `Cell::update()` method

Are there more elegant solutions to utilize?

Answer: 
I would probably pass a reference to the `Game` into `Cell::update()` and then tell the Game object to divide the cell, but other options may be better as I still don't think I have a full picture of what your overall goal is.
Pass a reference to `Game` into the `Cell` constructor. Then make a function that lets a `Cell` push other `Cell` objects onto the list (or make `Cell` a friend class of `Game` so that it can access the list directly).

This way, `Cell` can decide when it needs to split, but it can delegate the action to the `Game` object where it belongs.

Also, if there are any future thing that the `Cell` might want the `Game` to do for it, he already has a hold of the right object.