C++/pimpl: raw pointer or unique_ptr? What is a better choice?

Question

When you use a unique_ptr<T> for a forward declared type T, the unique_ptr destructor requires the T is complete, but the move assignment operator as well (and reset), according to this table:

https://stackoverflow.com/a/6089065/1794803

So, for your pImpl idiom, to implement it correctly, you have to declare the delete and the move assignment method (which, as side effect, marks them non-inlined):

class impl_t;

class A
{
   std::unique_ptr<impl_t> p_impl;

public:
   // Implement in A.cpp as A::~A() = default;
   ~A();

   // Implemented in A.cpp as A& operator=(A&&) = default;
   A& operator=(A&& he);
};

But, since std::unique_ptr is a RAII-solution for dynamic memory, and you pImpl is already inside a class, and you are forced to write a destructor anyway, isn't it better to just manage a raw pointer, since you class is already a RAII-like from the point of view of p_impl?:

class impl_t;

class A
{
    impl_t* p_impl;

public:
    ~A(); // The destructor must be written anyway.

    // The omitted move assignment destructor doesn't cause UB.
};

Isn't that a better solution? (+ defined or delete your own copy/move operator if you want to class is copyable/movable or not; but that is a "conscious choice"; however, don't writting a move assignment for unique_ptr is an error).

Using a unique_ptr only saves you for written a delete p_impl in a destructor that you have to declare anyway.

unique_ptr is an excellent choice for local dynamic objects which will be destructed even in case of exceptions, but for "attributes", you save nothing but the possibility of getting UB if you don't remember you have to rewrite the move assignment operator.

πάντα ῥεῖ · Accepted Answer · 2016-12-10T18:16:39.440

4

Well, using a std::unique_ptr redeems you from bothering with the explicit delete for the p_impl.

Also it should work well in cases of concurrent access and exceptional cases in the constructor (which doesn't seem to be guaranteed using a raw pointer and new yourself).

edited Dec 10 '16 at 18:16

answered Dec 10 '16 at 17:42

πάντα ῥεῖ

1
13
116
190

Moreover, an `std::unique_ptr` without a custom deleter is comparable to a raw pointer in terms of size, once optimized. – skypjack Dec 10 '16 at 18:14

score 0 · Answer 2 · answered Dec 10 '16 at 18:13

0

std::unique_ptr should be the preferred way for pimpl according. For reference, see Herb Sutter's talk at CppCon16 at around 10mins. The reason is, it will prevent you from accidently changing your pimpl while maintining RAII.

answered Dec 10 '16 at 18:13

pokey909

1,797
1
16
22

score 0 · Answer 3 · answered Oct 29 '22 at 12:48

In the question, the not needing to define a move assignment operator is given as a desired advantage. Below I suggest yet another solution that ‘also’ has this advantage, plus that you don’t need to define the destructor. Still I think the most important advantage of the solution below is that the implementation can now be defined in an anonymous namespace (or unnamed namespace). The price you have to pay is the declaration of a (reusable) base class: impl_t.

#include <iostream>
#include <memory>

////////////////////////
// a utility impl.h file
struct impl_t
{
    virtual ~impl_t() = 0;
};
inline impl_t::~impl_t() {}

///////////////////////
// the a_class.cpp file
class a_class_t
{
    std::unique_ptr<impl_t> m_pimpl;
public:
    a_class_t();
    int a_method(int);
};

///////////////////////
// the a_class.cpp file
namespace { // anonymous

struct a_class_impl_t
    : impl_t
{
    int a_method(int x)
    {
        return x + 1;
    }
    ~a_class_impl_t()
    {
        std::cout << "~a_class_impl_t()\n";
    }
};

} // anonymous namespace

int a_class_t::a_method(int x)
{
    return dynamic_cast<a_class_impl_t&>(*m_pimpl).a_method(x);
}

a_class_t::a_class_t()
    : m_pimpl(std::make_unique<a_class_impl_t>())
{}

////////////////////
// the main.cpp file
int main()
{
    a_class_t a_class;
    std::cout << a_class.a_method(1) << '\n';
}

And also this solution is best of with a unique_ptr.

C++/pimpl: raw pointer or unique_ptr? What is a better choice?

3 Answers3