Should I use delete or delete[] when receiving either a dynamic array or heap object?

Question

Say I have two items on the heap:

Foo *f = new Foo;
Foo *g = new Foo[42];

And say I have a function that receives a Foo pointer and within the function it needs to perform a delete:

void bar(Foo *p) {
    // some stuff
    delete p;
}

This function might be called like so:

bar(f); // passing a pointer to a Foo object on the heap
bar(g); // passing a pointer to an array on the heap

I recognize that delete[] and delete should be used to free memory allocated with new[] and new respectively; However since the function doesn't know if its parameter p was allocated with new or new[], how can this function properly delete or delete[]?

The goal of modern C++ is to never have to write `delete`. Use smart pointers, vectors, etc. — Alexandre C., Apr 21 '12 at 15:44

score 4 · Answer 1 · answered Apr 21 '12 at 15:49

It sounds like you have a problem with the Single Responsibility Principle.

You have some amount of processing that operates on a single object, so it's reasonable to pass an individual object or an array. (Why isn't that processing also useful for an array element other than the first, or a non-dynamic object?)

And then you have to free the object. Or the array.

There are three different tasks here, which calls for three different functions.

Essentially, if "the function doesn't know if its parameter p was allocated with new or new[]", that function has no business trying to deallocate. What if the parameter is on the stack? What if a pooled allocator was used?

Also, once the processing is moved to a separate function, it becomes easy to make a function for "process then delete single object" and also "process then delete array" without duplication (both call the helper function for the processing component).

score 3 · Accepted Answer · answered Apr 21 '12 at 15:42

3

You can't (portably) detect that and do the right thing in the function.

A "workaround" would be to use std::vector<Foo> instead of the array, and just always use delete.

answered Apr 21 '12 at 15:42

Joachim Isaksson

176,943
25
281
294

score 2 · Answer 3 · answered Apr 21 '12 at 15:56

Solution 1. From a code design point of view, you should probably avoid cases like this altogether, and have the object be deleted by the same class, pair of create-destroy functions, or code block that allocated it. This way, you know you're not making any mistakes.

Solution 2. If you compiler supports them, use std::shared_ptr and lambda functions, and use a different deallocator for each pointer, as appropriate. Read about shared pointers here.

std::shared_ptr<Foo> f(new Foo[20], [](Foo* p) { delete[] p; });
std::shared_ptr<Foo> g(new Foo);

The first one, f is a shared pointer to an array. When I create it, I give as the first parameter a (normal) pointer to the array; the second parameter is a lambda function that takes a Foo* p parameter and its body is { delete[] p; }.

By default, std::shared_ptr uses delete to deallocate memory. This is why, when I create the second one, I only give it the pointer to the object and don't specify any custom deallocator.

Eric Z · Answer 4 · 2012-04-21T16:08:14.143

You can't. You never know if a pointer points to an object or an array of such object.

But, if you really want to have a single function for deallocation, and if you can ever ever remember to allocate anything like an array even if you're allocating one object, the following use is legal:

Foo *h = new Foo[0];
Foo *f = new Foo[1];
Foo *g = new Foo[42];

void bar(Foo *p) {
    // some stuff
    delete [] p;
}

However, remember that sometimes technically possible doesn't mean that you should use it. That depends on your use case whether it makes sense to treat an object as a special case of an array.

The more elegant C++ way is to use std::vector or boost::scoped_ptr, boost::scoped_array, etc, which guarantee to call correct version of delete operator, just as their names indicate.

This is not really a good suggestion. Sure, it's a possibility but it creates more problems than it solves. — jmucchiello, Apr 15 '13 at 03:08

score 0 · Answer 5 · edited May 23 '17 at 12:15

0

You have to pass which it is. The function can't determine that at runtime.

See here for a good explanation.

edited May 23 '17 at 12:15

Community

1
1

answered Apr 21 '12 at 15:42

N_A

19,799
4
52
98

How, exactly, would one "pass which it is" ? – ybakos Apr 21 '12 at 15:50
I guess I'm assuming you know which one you're passing in. If you' don't know that then it's not possible to determine it. – N_A Apr 21 '12 at 15:59

score -2 · Answer 6 · answered Apr 21 '12 at 15:43

-2

It's up to the compiler vendor to decide how this should be implemented, and as such falls under the "magic" category.

In general though, the runtime will allocate an extra additional 4 bytes when you use new[]. Then it will store the size of the array in these bytes, and return the allocation + 4 bytes. When deallocating, it will remove 4 from the pointer you passed it, read the size and use that to decide how many destructors etc. to call.

You can read more about this in the C++ FAQ

answered Apr 21 '12 at 15:43

Hampus Nilsson

6,692
1
25
29

There's no such thing as magic. The answer here isn't relevant to the question. – ybakos Apr 21 '12 at 15:47
This is not guaranteed by the language standard. You shouldn't rely on it. – Paul Manta Apr 21 '12 at 15:59
If the program in question doesn't need to be portable, then relying on a specific C++ implementation is a valid thing to do. One just needs to understand and accept the implications going in. – Jeremy Friesner Apr 21 '12 at 16:17

Should I use delete or delete[] when receiving either a dynamic array or heap object?

6 Answers6