Question

I’m not a very experienced c++ coder and this has me stumped. I am passing a object (created elsewhere) to a function, I want to be able to store that object in some array and then run through the array to call a function on that object. Here is some pseudo code:

void AddObject(T& object) {
  object.action(); // this works

  T* objectList = NULL;
  // T gets allocated (not shown here) ...
  T[0] = object;
  T[0].action(); // this doesn't work
}

I know the object is passing correctly, because the first call to object.action() does what it should. But when I store object in the array, then try to invoke action() it causes a big crash.

Likely my problem is that I simply tinkered with the .’s and *’s until it compiled, T[0].action() compliles but crashes at runtime.

Answer 1

The simplest answer to your question is that you must declare your container correctly and you must define an appropriate assigment operator for your class. Working as closely as possible from your example:

typedef class MyActionableClass T;
T* getGlobalPointer();

void AddInstance(T const& objInstance)
{
    T* arrayFromElsewhere = getGlobalPointer();

//ok, now at this point we have a reference to an object instance
//and a pointer which we assume is at the base of an array of T **objects**
//whose first element we don't mind losing

//**copy** the instance we've received
    arrayFromElsewhere[0] = objInstance;

//now invoke the action() method on our **copy**
    arrayFromElsewhere[0].action();

}

Note the signature change to const reference which emphasizes that we are going to copy the original object and not change it in any way.

Also note carefully that arrayFromElsewhere[0].action() is NOT the same as objInstance.action() because you have made a copy — action() is being invoked in a different context, no matter how similar.

While it is obvious you have condensed, the condensation makes the reason for doing this much less obvious — specifying, for instance, that you want to maintain an array of callback objects would make a better case for “needing” this capability. It is also a poor choice to use “T” like you did because this tends to imply template usage to most experienced C++ programmers.

The thing that is most likely causing your “unexplained” crash is that assignment operator; if you don’t define one the compiler will automatically generate one that works as a bitwise copy — almost certainly not what you want if your class is anything other than a collection of simple data types (POD).

For this to work properly on a class of any complexity you will likely need to define a deep copy or use reference counting; in C++ it is almost always a poor choice to let the compiler create any of ctor, dtor, or assignment for you.

And, of course, it would be a good idea to use standard containers rather than the simple array mechanism you implied by your example. In that case you should probably also define a default ctor, a virtual dtor, and a copy ctor because of the assumptions made by containers and algorithms.

If, in fact, you do not want to create a copy of your object but want, instead, to invoke action() on the original object but from within an array, then you will need an array of pointers instead. Again working closely to your original example:

typedef class MyActionableClass T;
T** getGlobalPointer();

void AddInstance(T& objInstance)
{
    T** arrayFromElsewhere = getGlobalPointer();

//ok, now at this point we have a reference to an object instance
//and a pointer which we assume is at the base of an array of T **pointers**
//whose first element we don't mind losing

//**reference** the instance we've received by saving its address
    arrayFromElsewhere[0] = &objInstance;

//now invoke the action() method on **the original instance**
    arrayFromElsewhere[0]->action();

}

Note closely that arrayFromElsewhere is now an array of pointers to objects instead of an array of actual objects.

Note that I dropped the const modifier in this case because I don’t know if action() is a const method — with a name like that I am assuming not…

Note carefully the ampersand (address-of) operator being used in the assignment.

Note also the new syntax for invoking the action() method by using the pointer-to operator.

Finally be advised that using standard containers of pointers is fraught with memory-leak peril, but typically not nearly as dangerous as using naked arrays :-/