Behaviour of delete[] (ptr, 0)

Question

Is the behaviour of this code defined?

int* ptr = new int[10];
operator delete[] (ptr, 0);

This code compiles fine and (on my machine) it seems nothing is happening. Is its the behaviour defined somewhere?

[This `operator delete` and `operator delete[]` reference](https://en.cppreference.com/w/cpp/memory/new/operator_delete) should be helpful. Exact which overload you're calling is hard to say though. — Some programmer dude, Jul 26 '19 at 12:32
I think it's undefined behaviour. The comma operator evaluates `ptr` and discards the result, then passes `0` (an invalid address) to delete — Tharwen, Jul 26 '19 at 12:33
@Tharwen It's a function call. There is no comma operator here. — Rakete1111, Jul 26 '19 at 12:35
@Tharwen 0 is a valid address to delete. It is a null pointer literal. — eerorika, Jul 26 '19 at 12:36
@Rakete1111 I see that now. How can it take 2 arguments though? — Tharwen, Jul 26 '19 at 12:38
@eerorika I (mistakenly) thought deleting a null ptr was equivalent to deleting memory that hadn't been allocated with new and therefore undefined — Tharwen, Jul 26 '19 at 12:39
@Tharwen They can have 3 arguments even! :) Have a look: https://en.cppreference.com/w/cpp/memory/new/operator_delete — Rakete1111, Jul 26 '19 at 12:39

Vlad from Moscow · Answer 1 · 2019-07-26T12:45:57.723

0

In this statement

operator delete[] (ptr, 0);

there is called explicitly the deallocation function

void operator delete[](void*, std::size_t) noexcept;

The second parameter in the call that has the type size_t is just set to 0.

The behavior of the call then the second parameter is equal to 0 is undefined provided that when the allocated memory was not have the size equal to 0.

edited Jul 26 '19 at 12:45

answered Jul 26 '19 at 12:32

Vlad from Moscow

301,070
26
186
335

2

It's an operator call? It's not the comma operator but the arguments to the operator. – Rakete1111 Jul 26 '19 at 12:34
2

That would be `delete[](ptr, 0)` (without the `operator` keyword). Now the OP is calling the operator function directly. – Some programmer dude Jul 26 '19 at 12:35
2

@VladfromMoscow It's not better. There is no comma operator. `f(1, 2)` is not equivalent to `f(2)`. Here `f` is `operator delete[]`. – Rakete1111 Jul 26 '19 at 12:36
@Rakete1111 Og, you are right. I will delete the post.:) – Vlad from Moscow Jul 26 '19 at 12:37
Does it? Cppreference states that it *Called instead of (1-2) if a user-defined replacement is provided* and the OP has not mentioned overloading the operator. – NathanOliver Jul 26 '19 at 12:42
Also the OP is asking if it is defined behavior. Is it defined behavior to give it an incorrect size? – NathanOliver Jul 26 '19 at 12:43

score 0 · Answer 2 · answered May 12 '23 at 19:30

tl;dr: The behavior might as well be undefined, avoid such a statement.

_{This answer is aimed at most C++ software developers, not so much at language-lawyer types who want the formal official answer.}

The delete[](ptr, 0) call has no strong reason for the standard committee to define behavior for. Also, even if such a behavior were to be defined - there is no single obvious behavior we would expect:

It could throw an exception.
It could do nothing.
It could be the same as delete[](ptr) or delete[](ptr, 10).
It could be even be 'defined' as implementation-defined...

It is not a good idea for your code to rely on such a choice, even if the standards committee had made it. It would make your code difficult to understand and easy to break - for somebody else, or even for yourself, a few years down the line.

That's why it doesn't really matter whether the behavior here is defined, and you should absolutely avoid such a statement.

Behaviour of delete[] (ptr, 0)

2 Answers2

tl;dr: The behavior might as well be undefined, avoid such a statement.