Pointers to a class within void function - c++

Question

I am learning how classes/inheritances/pointers work in C++ and coding the following.
I have a class unit declared as such:
class unit{
public:
int locationX,locationY;
//genotype (does not change)
float agility, build,size,stamina, aggression;
//phenotype (changes based on genotype and stimuli)
float speed, strength, hunger;
};
When I create a new instance to pass into a void function (below, respectively), the memory is not allocated yet.
Instance
unit **units = 0;
Void Function Prototype
void initialize(grid *grids, unit **units /*, plant **plants, predator **predators */);
The memory is allocated within the void function using some parameters:
void initialize(grid *grids, unit **units,plant **plants,predator **predators)
{
units = new unit*[int(((grids->gridHeight)*(grids->gridWidth)*(grids->gridDivision))/20)];
for(register int i = 0; i<int(((grids->gridHeight)*(grids->gridWidth)*(grids->gridDivision))/20); i++)
{
units[i] = new unit;
units[i]->hunger = 5;
units[i]->locationX = (rand()%((grids->gridWidth)-0));
units[i]->locationY = (rand()%((grids->gridHeight)-0));
//etc, etc
}
}
However, once I exit the void function, the data I just stored gets deleted. Is there something wrong with the pointer declarations and passing into the function (which is as follows)?
initialize(&environment, units, plants, predators);
NOTE: I only have problems with the units variable declared under unit class. The environment variable is fine. The other two (plants and predators) are similar to units, so if this is fixed, I can fix the others.
Second Note: The main function is as follows (relevant parts):
int main()
{
unit **units = 0; //<--- Important one
plant **plants = 0;
predator **predators = 0;
grid environment(250,250,5); //Constructor for environment (don't mind this)
initialize(&environment, units, plants, predators); //<-- Void function
running = true;
return 0;
}
Thank you for any help/links/explanations you can provide.

Answer 1

You pass units into the function by value. This means that the units pointer within the function starts out as a copy of the one in the calling code. Within the function you assign a new value to the local units variable (i.e. the address of some newly created objects). Then when the function terminates, the local variable passes out of scope and the objects it pointed to are lost. The pointer in the calling code is never modified, and knows nothing about any of this.
Pass it by reference instead:
void initialize(grid *grids, unit ** &units)

Answer 2

You're passing "units" as a type "unit**" which is on the stack. When you assign a new value to the variable "units", you're affecting the variable local to the function. If you want the calling code to have it's variable "units" updated, you must pass it in by pointer or by reference.
Easiest way to fix this is to change your function signature to:
void initialize(grid *grids, unit **&units, etc.. );
this is passing the variable units as a reference to a pointer to a pointer to a unit.

Answer 3

Initializing a pointer (or array) A * a inside a method is a particular case of modifying your variable a (which is a pointer/array in this case). Modifying a variable inside a method can be done either by passing a pointer to it, or a reference to it. So in the case your variable is already a pointer, these two options are the following.
By passing a pointer to your pointer a:
void init(A * *a)
{
*a = new A(); // or "new A[n]" if "a" is an array
}
void main()
{
A * a;
init(&a);
}
Or passing a reference to your pointer:
void init(A * &a)
{
a = new A(); // or "new A[n]" if "a" is an array
}
void main()
{
A * a;
init(a);
}
So in your case, a is an array of unit* (which I think is a bad design by the way, it would be better to simply use an array of unit and save you from this loop to dynamically allocate separately all units), so basically a is of type unit ** so your A is actually the type unit*. Using the second method would lead to:
void init(unit* * &units)
But as I said, it is probably better to simply use an array of unit instead, and your whole code would look like:
void initialize(unit * &units /* etc */)
{
// note that I use unit instead of unit* here
units = new unit[n];
for(register int i = 0; i<n; i++)
{
// note that I remove the "new unit;" here
// note that I use "." instead of "->"
units[i].hunger = 5;
units[i].locationX = (rand()%((grids->gridWidth)-0));
units[i].locationY = (rand()%((grids->gridHeight)-0));
//etc, etc
}
}
void main()
{
unit * units;
initialize(units);
}