Initializing a reference to member to NULL in C++

Question

Is it possible to initialize a reference member to NULL in c++?
I'm trying to something like this:

class BigClass
{
private:
    Object m_inner;
public:
    const Object& ReadOnly;
    BigClass() : ReadOnly(NULL)
    {
      Do stuff.
    }
};

I know I can do this if I initialize "ReadOnly" to a real reference of an object, but when I want to put in there "NULL", i get the error:

"cannot convert from 'int' to 'const Object &'

How can I solve this?

Answer 1

No, references cannot be NULL in C++.¹

Possible solutions include:

• using a pointer instead of a reference.
• having a dummy Object instance that can be used to indicate "no object".

---

_{[1] From the C++11 standard:}

_{[dcl.ref] [...] a null reference cannot exist in a well-defined program, because the only way to create such a reference would be to bind it to the “object” obtained by dereferencing a null pointer, which causes undefined behavior.}

Answer 2

You cannot "solve" this. Use a pointer if you want to be able to have that member not point to anything.

References must be initialized to a real object, they cannot "point nowhere".

Answer 3

Use a pointer:- const Object* pReadOnly;

Answer 4

It can be done but it is almost certainly an extremely bad idea. The way to do it is to dereference a suitably typed NULL pointer which already shows that it is a bad idea: you arrive at undefined behavior at this point which, however, typically tends to "work".

In C++ references are meant to always refer to an actual object. This is different to other programming languages where "references" are actually the equivalent of pointers in C++ (typically without things like pointer arithmetic). What you probably actually want (you unfortunately didn't say what you try to achieve it but asked about a solution to a problem which is probably part of a misguided approach) is to use a pointer instead:

Object const* const readOnly;
BigClass(): readOnly(0) {}

Answer 5

It's useful in writing unit-tests. That is the only place it should be done, but there, it's quite helpful.

 Bar& bar(*static_cast<Bar*>(0));
 MockClass mock; // derives from RealClass
 mock.foo(bar);

Here, I am testing code which uses MockClass, not MockClass itself.

It's not a panacea, but it can help. Also, GoogleMock might be your friend if you are mocking "concrete" classes.

struct Bar;
struct RealClass {
  int& x_;
  double& y_;
  RealClass(int& x, double& y) :x_(x), y_(y) {}
  virtual void foo(Bar&);
};
struct MockClass: public RealClass {
  MockClass(): RealClass(*(int*)0, *(double*)0) {}
  MOCK_METHOD1(foo, void(Bar&));
};