C++ Dynamic Memory Best Practice - c++

Question

I'm learning C++ and I ran into a bit of code that I'm confused on what exactly it does. I'm learning dynamic memory and the place I'm learning it from mentioned that this was good practice.
double * pvalue = NULL;
if(!(pvalue = new double)){
cout<<"Error: out of memory." << endl;
exit(1);
}
I understand that you are creating a pointer called pvalue, but I don't understand the if statement. If someone could explain it to me I'd be greatly appreciated.

Answer 1

I'm confused on what exactly it does.
Working with a very outdated notion and limited understanding of C++.
First of all, C++ does not report a failure to allocate memory by returning NULL. It throws an exception, of type std::bad_alloc (which is derived from std::exception).
Second, with the advent of C++11, using "naked" pointers like that is frowned upon, because they all-too-easily result in resource leaks when you forget to delete them, e.g. when an unexpected exception makes your pointer go out of scope.
So you really should use either std::shared_ptr<> or unique_ptr<>.

Answer 2

pvalue = new double // This allocates a dynamic double as usual
!(pvalue = new double) // This takes the value of the resulting pointer
// and negates it, checking whether it's null
if(!(pvalue = new double)) // It all becomes the condition for the if.
It's worth noting that:
Raw owning pointers must not be used in C++, use smart pointers instead;
using namespace std; (which I'm certain this sample has) must not be used;
Dynamically allocating a single double is weird;
Plain new will never return a null pointer, so the check is meaningless;
std::exit will nuke your program mid-flight, leaking all objects with automatic lifetime, return from main instead.
[...] the place I'm learning it from mentioned that this was good practice.
It's time to put on some heavy metal and sunglasses, set fire to "the place" and go find some better learning material.

Answer 3

This:
if(!(pvalue = new double)){
... is just a (perhaps-too) clever shorthand way of writing this:
pvalue = new double;
if (pvalue == NULL) {...}

Answer 4

new never returns nullptr unless you provide std::nothrow. Rather, if new fails it will throw std::bad_alloc.
The more appropriate solution would be something like :
#include <iostream>
#include <stdexcept>
double * foo()
{
double * pvalue = nullptr;
try {
pvalue = new double;
}
catch(const std::bad_alloc &) {
std::cout << "Error: out of memory." << std::endl;
exit(1);
}
return pvalue;
}
However, using raw owning pointers is discouraged in modern code. new is generally avoided in favor of std::make_unique or std::make_shared. For example, an better solution would be something like this :
#include <iostream>
#include <memory>
#include <stdexcept>
std::unique_ptr<double> foo()
{
try {
return std::make_unique<double>();
}
catch(const std::bad_alloc &) {
std::cout << "Error: out of memory." << std::endl;
exit(1);
}
}