How can I create a constructor (c++) that creates a null object when it fails?

Question

How can I create a constructor (c++) that creates a null object when it fails.

I want to create a class that behaves like DicomImage class from the DCMTK lib.

#include "diregist.h"   /* required to support color images */
DicomImage *image = new DicomImage("test.dcm");

if (image != NULL)
{
    if (image->getStatus() == EIS_Normal)
    {
        Uint8 *pixelData = (Uint8 *)(image->getOutputData(8 /* bits per sample */));

        if (pixelData != NULL)
        {
            /* do something useful with the pixel data */
        }
    } 
    else
        cerr << "Error: cannot load DICOM image (" << DicomImage::getString(image->getStatus()) << ")" << endl;
}
delete image;

Answer 1

Not easily. You could override DicomImage::operator new() inside the declaration for DicomImage class. Then the actual logic that could fail and return NULL, would go into the operator new() body, not the actual constructor. Once you are inside the constructor it's too late to return NULL, at that point the object is already created. The problem is that operator new() doesn't receive constructor parameters so you may not have information needed in order to fail.

Another way would be to have a factory method or a factory class actually create your instance, so your code would look like:

DicomImage* pImage = CreateDicomImage( "stuff" );

However because your question had "exception handling" in it... and to make, at least the answer, a little more suitable of a programmers SE (as opposed to stackoverflow) question, I do want to point out that you could and should take advantage of exception handling in C++.

When you return NULL, you force all the client code to sprinkle error checking logic right after the call to new DicomImage() which takes away from readability since error checking tends ends up intermingled with actual application logic.

Wouldn't it be better to have code that looks like:

std::unique_ptr< DicomImage > pImage( new DicomImage( "stuff" ) );
pImage->DoSomeCommand();
pImage->DoSomeOtherCommand();

... and not have to worry about "what-if" conditions if creation failed. You could achieve this by using C++ exception handling and having the constructor throw exceptions if creation fails. Setup try-catch block around the chunk of code that deals with this stuff and what goes inside that try block is pure application logic. No error checking polluting the code and no crashes if image creation fails.

...and by using the smart pointer, you also guarantee that if anything later on fails, pImage will always get deleted. So you never need to worry about having to call delete prior to exiting the function.

Answer 2

The code that uses DicomImage doesn't do what you think it does.

The example code

if (image != NULL)
{

is defensive programming for an exception-less environment that returns NULL when the system is out of memory.

With exceptions enabled, new will throw an out of memory exception. If exceptions are disabled, then new will return NULL.

To answer your question, a constructor cannot return NULL.

However, a static factory method can return NULL.

class Foo
{
public:
    static Foo* MakeFoo()
    {
       Foo* foo = NULL;
       if (LifeIsGood())
           foo = new Foo();
       return foo;
    }
private:
    Foo();
};

Foo* myFoo = Foo::MakeFoo();
if (myFoo)
    BeFooish(myFoo);

Answer 3

I don't think a constructor can do this - this url says a constructor can't return null

http://social.msdn.microsoft.com/forums/en-US/csharplanguage/thread/1450ed84-277f-46d3-b2ea-8352986f877c

Maybe there is a "hack" but it is probably not legal You probably already know all of this but just in case: (1) A constructor can't return a value, and (2) I don't think it has any control over the memory allocated to the instance that invoked the constructor, but a constructor can set class members to NULL values.

This URL has a workaround - if you really need to use NULL (not recommended) making the constructor private and using a "factory method" (function):

Can a constructor return a NULL value?

I know this is separate from your question but I just wanted to make sure someone is aware of the compiler behavor with regards to new:

According to this URL, up-to-date compilers are not supposed to return NULL with the new operator (are supposed to throw an exception instead), although older compilers are allowed to do it:

http://www.parashift.com/c++-faq-lite/new/new-never-returns-null.html

Answer 4

You can't, and judging by the documentation of DicomImage, you really don't want to emulate that class's interface.

Answer 5

Doing this using the new() operator is not really the purpose for which overriding the new() operator was intended. From your example, I'm not sure if you are allowing changing the client code; however if you can control the client code, instead just use a factory method where you would use a constructor:

class Foo {

  Foo(int arg) {...}

  static Foo *new_Foo(int arg) {
    if (! I_like(arg)) return null;
    return new Foo(arg);
  }

}

// ...
// in the client

Foo *foo =
// nope:
// new Foo(3);
// do this instead:
Foo.new_Foo(3);

Answer 6

You can not return null in an object creation, however you can change the behavior of operator == and!= Try the following code, I have not tried.

bool MyClass::operator==(const MyClass &other) const {
    if(&other == null){
        if(/* your validations */){
            return true;//it is null
        }else{
            return false;//
        }       
    }
    return (*this == other);//it is not compare with null
}
bool MyClass::operator!=(const MyClass &other) const {
    if(&other == null){
        if(/* your validations*/){
            return true;//is not null
        }else{
            return false;
        }       
    }
    return !(*this == other);//it is not compare with null
}