Any way to detect whether the pointer points to array?

Question

Hi, everyone!

Is there any way to detect, whether the pointer points to array in C++? My problem is that I want to implement a class, that becomes the owner of the array. My class is initialized with the pointer and I would like to know, whether the pointer is really an array pointer. Here is the simplified code:

class ArrayOwner {
public:
   explicit ArrayOwner( int* initialArray ) : _ptrToArray(initialArray) {}
   virtual ~ArrayOwner() { delete [] _ptrToArray; }
private:
   int* _ptrToArray;
}

• This usage will be ok: ArrayOwner foo( new int[10] );
• But this usage leads to undefined behaviour: ArrayOwner foo( new int() );

I would like to add assert in the constructor, that the "initialArray" pointer is really an array pointer. I cannot change the contract of the constructor, use vectors e.t.c. Is there any way to write this assert in C++?

Answer 1

There's no portable way to do it.

Answer 2

No, unfortunately not. C++ RTTI does not extend to primitive types.

Answer 3

Generally, there is no (simple/portable/robust) way to do that.

Having said that, if you know your platform and you're willing to change your code for every new version of the OS, you might be able to find out where the heaps are and how they look like, so you may want to walk the heap and see the size of the block which this pointer points to, so you can calculate the number of items there. But everyone will advice you against doing that.

Answer 4

I don't think so. x[] and *x are synonyms except, of course, when you call delete on them.

Answer 5

It looks like a bad design to me. Don't separate new and delete this way.

The array should be allocated in the object constructor, not passed as a parameter.

Memory management in C++ is hard, don't make it harder with bad practice like this.