Calling delete on NULL pointers – C++03 vs C++11

by

It looks like we can find a rationale for this change in defect report 348, which says:

Specifically, standard says in 5.3.5 [expr.delete] paragraph 2:

…if the value of the operand of delete is the null pointer the operation has no effect.

Standard doesn’t specify term “has no effect”. It is not clear from
this context, whether the called deallocation function is required to
have no effect, or delete-expression shall not call the deallocation
function.

Furthermore, in para 4 standard says on default deallocation function:

If the delete-expression calls the implementation deallocation
function (3.7.4.2 [basic.stc.dynamic.deallocation]), if the operand of
the delete expression is not the null pointer constant, …

Why it is so specific on interaction of default deallocation function and delete-expr?

If “has no effect” is a requirement to the deallocation function, then
it should be stated in 3.7.4.2 [basic.stc.dynamic.deallocation], or in
18.6.1.1 [new.delete.single] and 18.6.1.2 [new.delete.array], and it should be stated explicitly.

part of the resolution was the change in wording that you noted, although the language around that phrasing has changed quite a bit but the logic of getting rid of the has no effect language still stands, it is not a well defined term and so should be replaced with well specified language.

More Related Contents:

  1. Can C++ code be valid in both C++03 and C++11 but do different things?
  2. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  3. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  4. reinterpret_cast creating a trivially default-constructible object
  5. Will std::string always be null-terminated in C++11?
  6. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  7. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  8. When is a private constructor not a private constructor?
  9. Is it still safe to delete nullptr in c++0x?
  10. Matching alias template as template argument
  11. Default, value and zero initialization mess
  12. Lambda capture and parameter with same name – who shadows the other? (clang vs gcc)
  13. So why is i = ++i + 1 well-defined in C++11?
  14. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  15. Does this code from “The C++ Programming Language” 4th edition section 36.3.6 have well-defined behavior?
  16. Why there is no placement delete expression in C++?
  17. Are int8_t and uint8_t intended to be char types?
  18. When do extra parentheses have an effect, other than on operator precedence?
  19. What is the difference between C++03 `throw()` specifier and C++11 `noexcept`?
  20. Is a constexpr array necessarily odr-used when subscripted?
  21. Legal to overwrite std::string’s null terminator?
  22. What differences, if any, between C++03 and C++11 can be detected at run-time?
  23. reinterpret_cast between char* and std::uint8_t* – safe?
  24. What is the difference between std::quick_exit and std::abort and why was std::quick_exit needed?
  25. How does =delete on destructor prevent stack allocation?
  26. Calling an explicit constructor with a braced-init list: ambiguous or not?
  27. C++11 cross compiler/standard library random distribution reproducibility
  28. Using std::bind with member function, use object pointer or not for this argument?
  29. memcpy/memmove to a union member, does this set the ‘active’ member?
  30. Overload resolution with ref-qualifiers

Leave a Comment