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 not introduce an unnecessary dependence between `Cell` and `Game`, if all `Game` does is to call methods on `Cell`s and hold instances of them.

You could instead return new `Cell`s (or none) from `Cell::update()` and let `Game` decide what to do, most probably add them to the list. You could also define a new function for this in `Cell`, something like `Cell::splitCell()` and let `Cell::update()` only update properties of `Cell` objects (as the name would suggest).
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.