Re: Null pointer from "new" operator.

On 2013-07-02 07:21, James K. Lowden wrote:


I don't think that this part of the wording is a suitable evidence for
the intention of the standard in regard to a non-null return value of
the new expression. This part just explains the difference between
array-new and not array-new in regard to the returned objects, it
doesn't require that the result is never null.

The concrete requirements for non-null results are imposed on the
global versions of the allocations functions via clause 18, where we
have in [new.delete.single] p3:

"Required behavior: Return a non-null pointer to suitably aligned
storage (3.7.4), or else throw a bad_alloc exception. This requirement
is binding on a replacement version of this function."

The requirement whether an allocation function shall return null or a
valid object is otherwise completely determined by the absence or
existence of an exception specification, see
[basic.stc.dynamic.allocation] p3:

"If an allocation function declared with a non-throwing
exception-specification (15.4) fails to allocate storage, it shall
return a null pointer. Any other allocation function that fails to
allocate storage shall indicate failure only by throwing an exception
(15.1) of a type that would match a handler (15.3) of type
std::bad_alloc (18.6.2.1)."

Note that clause 5 (relevant for the actual new expression) agrees
with that, paragraph 15 of 5.3.4 [expr.new] says:

"[ Note: unless an allocation function is declared with a non-throwing
exception-specification (15.4), it indicates failure to allocate
storage by throwing a std::bad_alloc exception (Clause 15, 18.6.2.1);
it returns a non-null pointer otherwise. If the allocation function is
declared with a non-throwing exception-specification, it returns null
to indicate failure to allocate storage and a non-null pointer
otherwise. ?end note ] If the allocation function returns null,
initialization shall not be done, the deallocation function shall not
be called, and the value of the new-expression shall be null."


You are right that the new expression can be considered as "template
pattern" that uses the actual allocation function to construct an
object. But it also has to cope with allocation functions returning
null. Under well-specified circumstances the allocation function may
return null (determined by the nature of the exception-specification).
Class-specific allocation functions are not constrained by the
fundamental "non-null" return value (The case of a class-specific
allocation function was excluded by the OP, but I think it needs to be
mentioned in a context where I want to convince someone that a null
test of the return value of a new expression is totally
redundant). IMO the following program is well-defined and is required
to output

OK, null pointer

//------------------------------------------------------------
#include <cstdio>
#include <cstddef>

struct C {
    static void* operator new(std::size_t) throw() { return 0; }
    static void operator delete(void*) throw() { }
    int i;
    C(int i) : i(i) {}
};

int main() {
    auto p = new C(23);
    if (p) {
      std::printf("Unexpected value %d\n", p->i);
    } else {
      std::printf("OK, null pointer\n");
    }
}
//------------------------------------------------------------

HTH && Greetings from Bremen,

Daniel Kr?gler

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]