pimpl-idiom

I'm reading Effective Modern C++ by Scott Meyers and he's discussing the use of the pimpl idiom and pointing to the implementation class with unique_ptr , but there is an issue of special member functions (such as destructors) requiring the type to be complete. This is because unique_ptr 's default deleter statically asserts whether the type to be deleted is complete, before delete p is used. So any special member functions of the class must be defined in the implementation file (rather than being compiler-generated), after the implementation class has been defined. At the end of the chapter,

d-pointers are heavily used in Qt, they are an implementation of pimpl idiom. I know advantages and disadvantages of pimpl idiom. But I have missed the advantages of d-pointers implementation. Here and here are the samples of d-pointers. Isn't it easier to just use this? class MyClassPrivate; class MyClass { // interface methods private: MyClassPrivate *pimpl_; }; The set of macros for d-pointer pattern provides some sort convenience and consistencies. For example, Q_DECLARE_PRIVATE ensures that the pimpl private class for Foo is named as FooPrivate, that FooPrivate befriends Foo, and creates

I have the following code: In DLL1: in .h file: class MyClass { public: MyClass(); private: std::string m_name; }; class __declspec(dllexport) Foo { private: struct Impl; Impl *pimpl; public: Foo(); virtual ~Foo(); }; struct Foo::Impl { std::vector<MyClass> m_vec; std::vector<MyClass> &GetVector() { return m_vec; }; }; in .cpp file: Foo::Foo() : pimpl ( new Impl ) { } Foo::~Foo() { delete pimpl; pimpl = NULL; } [EDIT] In DLL2 in .h class Bar : public Foo { public: Bar(); virtual ~Bar(); }; in .cpp: Bar::Bar() { } Bar::~Bar() { } In DLL3: extern "C" __declspec(dllexport) Foo *MyFunc(Foo *param)

boost::shared_ptr really bothers me. Certainly, I understand the utility of such a thing, but I wish that I could use the shared_ptr<A> as an A* . Consider the following code class A { public: A() {} A(int x) {mX = x;} virtual void setX(int x) {mX = x;} virtual int getX() const {return mX;} private: int mX; }; class HelpfulContainer { public: //Don't worry, I'll manager the memory from here. void eventHorizon(A*& a) { cout << "It's too late to save it now!" << endl; delete a; a = NULL; } }; int main() { HelpfulContainer helpfulContainer; A* a1 = new A(1); A* a2 = new A(*a1); cout << "*a1 = " <

In this question I unsuccessfully asked how to use different pimpl implementation depending on a template argument. Maybe this example ilustrates better what I am trying to do : #include <iostream> template< int N, typename T > struct B { B() : c( new C< N > ) {} template< int M > struct C; C< N > *c; }; template< int N, typename T > template< int M > struct B< N, T >::C { int a[M]; }; // version 1 that doesn't work template< int N, typename T > template< > struct B< N, T >::C< 0 > { int a; }; // version 2 that doesn't work template< typename T > template< int M > struct B< 0, T >::C { int a;