Allocate pointer array without using `new`?

Question

Here is my code:

int *arr1 = new int[size]();
int *arr2 = new int[size]();
int *arr3 = new int[size]();

I know, I know: I should be using std::unique_ptr if I need to use pointers, but I am required by an assignment to use * arrays (using "dynamic allocation" - I would use std::vector but that's not allowed either for some reason).

I know using new is bad practice, so is there a way to use a pointer array without using that keyword or having to do delete later on?

Answer 1

If we stick to 'classic' C++ (and not the latest bleeding edge standard), then you don't have unique_ptr or std::array, and the use of new is normal. It carries some risks of leaking storage (by failing to delete) or corrupting storage (by deleting twice), but it's your job to code things to avoid those issues.

However, there are ways of using new that are less likely to result in leaking memory, like the following. Note: This is not perfectly safe production code, just a tutorial example on the use of a class with a destructor to manage the lifetime of storage allocated with new.

class WithAnArray {
     private:
        int *storage;
     public:
        WithAnArray(unsigned size) {
           storage = new int[size];
        }
        ~WithAnArray() {
           delete[] storage;
        }
        int* getArray() {
           return storage;
        }
 }

Answer 2

C++11 introduced std::array :-) Is it a way to sidestep the problem? :-) :-)

The description is:

std::array is a container that encapsulates constant size arrays.

Example of use:

std::array<int, 3> a2 = {1, 2, 3};

Or you can even use std::unique_ptr, as in this example:

int size = 10; 
std::unique_ptr<int[]> fact(new int[size]);

for (int i = 0; i < size; ++i) {
    fact[i] = (i == 0) ? 1 : i * fact[i-1];
}

for (int i = 0; i < size; ++i) {
    std::cout << i << ": " << fact[i] << '\n';
}

Answer 3

There is nothing bad about the new keyword, it's always at the bottom of dynamic space allocation, even when you use std::vector<> and friends. std::unique_ptr and such have their issues as well. But this is not, what my answer is about.

My answer is about the cases, where you need to avoid new for performance reasons (it is a very costly operator, taking a few hundred cycles).

You can usually avoid allocating your array line by line, by simply allocating it all in one go, and building the pointer structure you need manually:

size_t fieldSize = width*height*sizeof(int);
size_t pointerArraySize = height*sizeof(int*);
char* memory = new char[fieldSize + pointerArraySize];
int** pointerArray = (int**)memory;
int* dataArray = (int*)&memory[pointerArraySize];
for(long i = height; i--; ) pointerArray[i] = &dataArray[i*width];

Ok, this is a little more hassle than doing many individual allocations, but quite a bit faster. And, as a bonus, deallocation is a one-liner:

delete[] (char*)pointerArray;

Answer 4

Question is if sizeis known (can be calculated) at compile time or only at runtime.

If the first situation applies, use std::array, with the latter there's no way without using new (indirectly) or some allocator surrogate passed to a STL container (e.g. std::vector).

Answer 5

You could just pass a reference to a static array sized on a huge number.

Answer 6

Anybody claiming that using new is bad practice shouldn't be allowed to develop any code, because if we expand such persuasion, then using pointers is also bad, using/developing COM objects is also bad, using heap is also bad... At the end of that demagogy would most probably be something like "using computers is bad practice, let's switch to stone age".

If you don't know how to use new/delete without creating a mess, hire somebody who does.