🔒 Locked

Passing an array of pointers to objects to a function

Started by ChaosWars Jun 29, 2008 at 11:41 AM 30 replies 8.9k views

Original Post

Jun 29, 2008 at 11:41 AM

I have a rather odd problem. I am trying to pass an array of pointers to objects to a function, which initializes and fills the array. It then returns the number of pointers to objects in the array. The code looks something like this:


class Material(){..}

class MaterialLoader(){
...
LoadMaterial(const char *path, Material *materials[] ){...}
}

The wierd thing is, when the LoadMaterial function is called from another class like this:

Material **materials = NULL;
MaterialLoader ml;
int num_materials = ml.LoadMaterial(path, materials);
printf("adress of materials is %x\n", materials);

the printf points to 0! The array is getting filled within the function, debugging the application as well as printf statements inside LoadMaterial confirm this. It is as though a copy is being made of materials, and that this is being passed to the function, but that's not possible, is it? And yet it must be, since that seems to be what is happening. Can someone shed some light on this? If you want to compile the code, it can be obtained from http://code.google.com/p/mll/ Thanks in advance.

Linolium

Jun 29, 2008 at 11:57 AM

Your function

LoadMaterial(const char *path, Material *materials[] ){...}

is incorrect. With this implementation C++ is thinking the array materials[] already exists somewhere- which is incorrect.

It should be

int LoadMaterial(const char *path, Material ***materials)
{
int number_of_materials = CountMaterials(path); // <-- helper function

// Create the array (I think this syntax is correct)
*materials = new Matirial *[number_of_materials];

// Do normal loading
...

// Return the count as specified in the prototype
return number_of_materials;
}

-Linolium

**EDIT** Corrected pointer parameter. I knew something didn't seem right in that code segment. Thanks rip-off for the reminder ;)

Basically you would call the function like:
ml.LoadMaterial(path, &materials);

rip-off

Mod

445

rip-off

Jun 29, 2008 at 12:02 PM

The pointer argument is a copy of the pointer passed to it. Changing the value of the "materials" argument in LoadMaterial() has no effect on the value of the variable "materials" in the other class.

One way would be to return a standard library container (vector) of (smart) material pointers:

#include <vector>class MaterialLoader{   std::vector<Material*> LoadMaterial(const std::string &path);};

Alternatively, you could pass the vector by reference.

#include <vector>class MaterialLoader{   void LoadMaterial(const std::string &path, std::vector<Material*> &materials);};

You could have returned the pointer in your code (but then you still have to do more manual memory management, and you have no size information):

class MaterialLoader{   Material **LoadMaterial(const std::string &path);};

The last solution (and IMO the worst choice) is to pass the pointer by reference. References to pointers are a little ugly syntax wise, but a typedef can help:

class MaterialLoader{   typedef  Material **ArrayOfMaterialPointers;   LoadMaterial(const std::string &path, ArrayOfMaterialPointers &materials);};

The last is really only shown for completeness and to demonstrate the references to pointers is a possible, if not always optimal, solution.

You code is very like this:

void foo( int *arg_ptr ){    delete arg_ptr;    arg_ptr = 0;}int main(){    int *main_ptr = new int(42);    foo(main_ptr);    // main_ptr was passed by value.    // the value of arg_ptr before it went out of scope is 0    // these changes are not made to main_ptr, it is now an invalid pointer}

Topic Locked