Auto pointer for unsigned char array?

Question

I'd need a class like std::auto_ptr for an array of unsigned char*, allocated with new[]. But auto_ptr only calls delete and not delete[], so i can't use it.

I also need to have a function which creates and returns the array. I came out with my own implementation within a class ArrayDeleter, which i use like in this example:

#include <Utils/ArrayDeleter.hxx>

typedef Utils::ArrayDeleter<unsigned char> Bytes;

void f()
{
  // Create array with new
  unsigned char* xBytes = new unsigned char[10];
  // pass array to constructor of ArrayDeleter and
  // wrap it into auto_ptr
  return std::auto_ptr<Bytes>(new Bytes(xBytes));
}

...
// usage of return value
{
  auto_ptr<Bytes> xBytes(f());
}// unsigned char* is destroyed with delete[] in destructor of ArrayDeleter

Is there a more elegant way to solve this? (Even using another "popular" library)

Answer 1

Boost has a variety of auto-pointers, including ones for arrays. Have you considered if std::vector is sufficient? Vectors are guaranteed to be contiguous in memory, and if you know the size and allocated memory ahead of time the location in memory will not change.

Answer 2

How about using std::basic_string<unsigned char>? Or maybe std::vector<unsigned char>?

Answer 3

I then have to call a methods that takes unsigned char* as argument.

std::vector<unsigned char> vec;
.
.
.
legacy_function(&vec[0], vec.size());

Answer 4

1. You're talking about an array of int, not complex C++ types that have a destructor. For such an array calling delete[] is equivalent to calling delete. So there's no problem to use std::auto_ptr.

2. The method you suggest is very barbaric IMHO. You actually allocate memory twice: once for the needed array, and then you also allocate an instance of ArrayDeleter, which encapsulates the pointer to the allocated array.

The drawbacks of such a method are:

• Worse performance. Heap operations are heavy. Also they have significant memory overhead.
• Slower access. To access an element of your array via the std::auto_ptr<Bytes> the compiler will generate two indirections: one to get your Bytes object, and the other to access the element. In simple words: std::auto_ptr has a pointer to Bytes object, which has a pointer to the array.
• Worse error/exception consistency. Imagine what if the operator new fails to allocate the Bytes object. It'll generate an exception, which may be handled. But at this point you've already allocated the array. And this allocation will be lost.

I'd do one of the following:

1. If you're talking about an ordinary type - just use std::auto_ptr<type>. This should do the work. However you should check it with your compiler.

2. For complex types: you may create your own wrapper instead of the std::auto_ptr.

3. Another variant: similar to what you did. However you should get rid of the extra memory allocations and indirections.