Filling an array of pointers, deleting when exiting

In C++, Lets say I'm creating an array of pointers and each element should point to a data type MyType. I want to fill this array in a function fillArPtr(MyType *arPtr[]). Lets also say I can create MyType objects with a function createObject(int x). It works the following way:

MyType *arptr[10]; // Before there was a mistake, it was written: "int *arptr[10]"
void fillArPtr(MyType *arptr[])
{
    for (int i = 0; i < 10; i++) 
    {
        MyType myObject = createObject(i);
        arptr[i] = new MyType(myobject);
    }
}

I开发者_StackOverflow社区s it the best way to do it? In this program how should I use delete to delete objects created by "new" (or should I use delete at all?)

---

Since you asked "What is the best way", let me go out on a limb here and suggest a more C++-like alternative. Since your createObject is already returning objects by value, the following should work:

#include <vector>

std::vector<MyType> fillArray()
{
  std::vector<MyType> res;
  for (size_t i = 0; i != 10; ++i)
    res.push_back(createObject(i));
  return res;
}

Now you don't need to do any memory management at all, as allocation and clean-up is done by the vector class. Use it like this:

std::vector<MyType> myArr = fillArray();
someOtherFunction(myArr[2]);   // etc.
someLegacyFunction(&myArr[4]); // suppose it's "void someLegacyFunction(MyType*)"

Do say if you have a genuine requirement for manual memory management and for pointers, though, but preferably with a usage example.

---

Your method places the array of pointers on the stack, which is fine. Just thought I'd point out that it's also possible to store your array of pointers on the heap like so. Youd do this if you want your array to persist beyond the current scope

MyType **arptr = new MyType[10]; 
void fillArPtr(MyType *arptr[])
{
    for (int i = 0; i < 10; i++) 
    {
        MyType myObject = createObject(i);
        arptr[i] = new MyType(myobject);
    }
}

If you do this, don't forget to delete the array itself from the heap

for ( int i = 0 ; i < 10 ; i++ ) {
    delete arptr[i];
}
delete [] arptr;

If you're going to use vector, and you know the size of the array beforehand, you should pre-size the array. You'll get much better performance.

vector<MyType*> arr(10);

---

for (int i = 0; i < 10; i++) 
{
    delete arptr[i];
    arptr[i] = 0;
}

I suggest you look into boost shared_ptr (also in TR1 library)

Much better already:

 std::vector<MyType*> vec;
 for (int i=0; i<10; i++)
    vec.push_back(new MyType(createObject(i));

 // do stuff

 // cleanup:
 while (!vec.empty())
 {
     delete (vec.back());
     vec.pop_back();
 }

Shooting for the stars:

 typedef boost::shared_ptr<MyType> ptr_t;
 std::vector<ptr_t> vec;
 for (int i=0; i<10; i++)
    vec.push_back(ptr_t(new MyType(createObject(i)));

---

You would basically go through each element of the array and call delete on it, then set the element to 0 or null.

   for (int i = 0; i < 10; i++)
   {
       delete arptr[i];
       arptr[i] = 0;
   }

Another way to do this is with an std::vector.

---

Use an array of auto_ptrs if you don't have to return the array anywhere. As long as you don't make copies of the auto_ptrs, they won't change ownership and they will deallocate their resources upon exiting of the function since its RAII based. It's also part of the standard already, so don't need boost to use it :) They're not useful in most places but this sounds like a good one.

---

You can delete the allocated objects using delete objPtr. In your case,

for (int i = 0; i < 10; i++) 
{
  delete arptr[i];
  arptr[i] = 0;
}

The rule of thumb to remember is, if you allocate an object using new, you should delete it. If you allocate an array of objects using new[N], then you must delete[] it.

Instead of sticking pointers into a raw array, have a look at std::array or std::vector. If you also use a smart pointer, like std::unique_ptr to hold the objects within an std::array you don't need to worry about deleting them.

typedef std::array<std::unique_ptr<MyType>, 10> MyTypeArray;
MyTypeArray arptr;

for( MyTypeArray::iterator it = arptr.begin(), int i = 0; it != arptr.end(); ++it ) {
  it->reset( new MyType( createObject(i++) ) );
}

You don't need to worry about deleting those when you're done using them.

Is the createObject(int x) function using new to create objects and returning a pointer to this?. In that case, you need to delete that as well because in this statement

new MyType( createObject(i++) )

you're making a copy of the object returned by createObject, but the original is then leaked. If you change createObject also to return an std::unique_ptr<MyType> instead of a raw pointer, you can prevent the leak.

If createObject is creating objects on the stack and returning them by value, the above should work correctly.

If createObject is not using new to create objects, but is creating them on the stack and returning pointers to these, your program is not going to work as you want it to, because the stack object will be destroyed when createObject exits.