Question

I need the flexibility of being able to change parameters passed around to different functions, depending from where the call to the function happened, so I decided I’d put all my parameters in a struct, however most of these parameters are structs or classes themselves and I want to have the option of leaving them NULL, so I have to pass pointers to the structs/classes.

struct A
{
    otherB* b;  // NULL should be a valid value
    otherC* c;
};

However my question is now, passing A around these pointers will be the only thing copied, so if I did the following there would be a problem right?

void func(A& a) //non const cause I wanna change contents of A.
{
   a.b = new b();
}

A myA;
otherC somec; // all these are currently automatic variables in my pgm.
myA.c = &somec;

func(myA);  //myA goes out of scope? so I've lost all pointers assigned and since somec is out of scope too, I have a problem?

What would the best way to resolve something like this+ I want the flexibility of being able to pass NULL to any of my parameters, however not sure if using raw pointers everywhere is a good idea?

Answer 1

To solve the problem of resource management, you should use boost::shared_ptr (or std::shared_ptr in C++0x).

struct A
{
    boost::shared_ptr< otherB > b;
    boost::shared_ptr< otherC > c;
};

void func(A& a)
{
   a.b = boost::make_shared< otherB >();
}

A myA;
otherC somec;
myA.c = boost::shared_ptr< otherC >(&somec, null_deleter());

func(myA);

When myA goes out of scope, all resources are deallocated automatically. Since somec was allocated on the stack, we wrapped it in a shared_ptr that uses a null_deleter, that could look like this:

struct null_deleter {
    void operator()(void *) { }
};

This will not delete the object, it will do nothing (which is just what we want for stack-allocated objects). Keep in mind however, that you have to make sure that somec lives longer than myA, otherwise you will get access violations.