Well, I'll just drop some things here.
If a compiler supports exceptions, at all, but doesn't ship with a `new' that throws an exception in the face of failure, you can always change that behavior directly all by yourself. The `new' operator is just an operator; it is an operator that calls `void * operator new (size_t)' which is only special in that it is the function that `new' calls by default. That said, if an exceptions capable compiler ships without a version of `new' that throws, it also probably doesn't have `std::bad_alloc' so you'll need to provide a definition for that as well.
If a compiler doesn't support exceptions, then the questionable source has no meaning because it will not compile.
If a compiler supports exceptions, but the exception mechanism is turned off the source will either not compile or fail to protect you at runtime because the throw will not be honored.
A very picky compiler may, in the face of an `void * operator new (size_t)' implementation that doesn't throw an exception, inform you that such an implementation goes against the standard. This behavior is certainly not required.
Because `void * operator new (size_t)' may be a user defined function linked by a third-party linker from third-party source a compiler will very likely never elide such an additional check and probably not issue a warning.
So, if you feel you need to code in practice against a version of `new' that doesn't throw you only have two realistic options.