auto_ptr pointing to a dynamic array

Question

In my code, I am allocating an integer array using new. After that I am wrapping this pointer to an auto_ptr. I know that the auto_ptr call its destructor automatically. Since my auto_ptr is pointing to an array (allocated using new), Will the array get deleted along with auto_ptr or will it cause a memory leak. Here is my sample code.

std::auto_ptr<int> pointer;

void function()
{
  int *array = new int[2];
  array[0] = 10;
  array[1] = 20;

  pointer.reset((int*) array);
}

int _tmain(int argc, _TCHAR* argv[])
{

    function();
return 0;
}

Answer 1

The array will not be deleted correctly. auto_ptr uses delete contained_item;. For an array it would need to use delete [] contained_item; instead. The result is undefined behavior.

As James McNellis said, you really want std::vector here -- no new, no auto_ptr and no worries.

Answer 2

You can not use std::auto_ptr to handle dynamic arrays, because it can not know how to differentiate between delete and delete[].

Moreover, auto_ptr is deprecated, in C++11 you can use std::unique_ptr with:

int *array = new int[2];
std::unique_ptr<int[]> pointer(array);

Answer 3

As others said auto_ptr is the wrong thing to use, std::vector is best. But you may also use boost::scoped_array. But note that you want to reset at time of creation otherwise you might as well use delete. pointer.reset(new int[2]);

or better yet like this boost::scoped_array arr(new int[2]);

Also there is no point to to create a static std::auto_ptr pointer; in global scope. This means it will get deleted only when the program exists, that happens anyway even if you leak memory.