CODEWITHSUNDEEP
c++design-patterns
mem64k
mem64k

Reputation: 748

Pros and Cons of usage of reference in case of PIMPL idiom

As mentioned here you can use reference (d-reference) instead of pointer (d-pointer) in case of PIMPL idiom.

I'm trying to understand if there are any serious issues with this implementation and what are the pros and cons.

Pros:

Cons:


if (m_Private)
  m_Private->Foo();

Here the sample code for illustration:

// Header file

class ObjectPrivate;

class Object
{
public:
 Object();
 virtual ~Object();

 virtual void Foo();

 private:
   ObjectPrivate&  m_Private;
};

// Cpp file

class ObjectPrivate
{
public:
  void Boo() { std::cout << "boo" << std::endl; }
};

Object::Object() :
m_Private(* new ObjectPrivate())
{
}

Object::~Object()
{
  delete &m_Private;
}

void Object::Foo()
{
  m_Private.Boo();
}

Upvotes: 4

Views: 2583

Answers (3)

justin
justin

Reputation: 104698

Some quick and obvious additions:

Pro

  • The reference must not be 0.
  • The reference may not be assigned another instance.
  • Class responsibilities/implementation are simpler due to fewer variables.
  • The compiler could make some optimizations.

Con

  • The reference may not be assigned another instance.
  • The reference will be too restrictive for some cases.

Upvotes: 1

Matt Yang
Matt Yang

Reputation: 659

It's not convenient to write exception-safe code I think.

The first version of Object::operator=(Object const&) might be:

Object& operator=(Object const& other)
{
    ObjectPrivate *p = &m_Private;
    m_Private = other.m_Private;        // Dangerous sometimes
    delete *p;
}

It's dangerous if ObjectPrivate::operator=(ObjectPrivate const&) throws exception. Then what about using a temporary variable? Aha, no way. operator=() has to be invoked if you want change m_Private.

So, void ObjectPrivate::swap(ObjectPrivate&) noexcept can act as our savior.

Object& operator=(Object const& other)
{
    ObjectPrivate *tmp = new ObjectPrivate(other.m_Private);
    m_Private.swap(*tmp);                // Well, no exception.
    delete tmp;
}

Then consider the implementation of void ObjectPrivate::swap(ObjectPrivate&) noexcept. Let's assume that ObjectPrivate might contain a class instance without swap() noexcept or operator=() noexcept. I think it's hard.

Alright then, this assumption is too strict and not correct sometimes. Even so, it's not necessary for ObjectPrivate to provide swap() noexcept in most cases, because it's usually a helper structure to centralize data.

By contrast, pointer can save a lot of brain cells.

Object& operator=(Object const& other)
{
    ObjectPrivate *tmp = new ObjectPrivate(*other.p_Private);
    delete p_Private;
    p_Private = tmp;        // noexcept ensured
}

It's much more elegant if smart pointers are used.

Object& operator=(Object const& other)
{
    p_Private.reset(new ObjectPrivate(*other.p_Private));
}

Upvotes: 1

James Kanze
James Kanze

Reputation: 153909

It's really just a matter of style. I tend to not use references in classes to begin with, so using a pointer in the compilation firewall just seems more natural. But there's usually no real advantage one way or the other: the new can only fail by means of an exception.

The one case where you might favor the pointer is when the object has a lot of different constructors, some of which need preliminary calculations before calling the new. In this case, you can initialize the pointer with NULL, and then call a common initialization routine. I think such cases are rare, however. (I've encountered it once, that I can recall.)

EDIT:

Just another style consideration: a lot of people don't like something like delete &something;, which is needed if you use references rather than pointers. Again, it just seems more natural (to me, at least), that objects managing memory use pointers.

Upvotes: 6

Related Questions