c++ - pimpl 助手与继承不明确

Question

我正在尝试为 pimpl idiom 创建一个实用程序类，但是我遇到了一些问题，希望得到一些帮助:

这就是我得到的:
[sehe:^{_{另请参阅此处的 rev.1:https://gist.github.com/1379569/9f6cca5703e6195da65e34103393d901dde3b1bf}} ]

pimpl.h

template<typename T>
class pimpl
{
    template <typename> friend class pimpl;

    pimpl(const pimpl& other);
    pimpl(pimpl&& other);
    pimpl& operator=(const pimpl& other);
    pimpl& operator=(pimpl&& other);    
protected:

    ~pimpl();

    struct implementation;
    std::unique_ptr<implementation> impl_;
public:
    pimpl();

    template<typename P0>
    pimpl(P0&& p0);

    pimpl(const T& other);
    pimpl(T&& other);

    void swap(T& other);
};

pimpl_impl.h

// #include "pimpl.h" // TODO add header guards...

template<typename T>
pimpl<T>::pimpl() : impl_(new implementation()){}

template<typename T>
template<typename P0>
pimpl<T>::pimpl(P0&& p0) : impl_(new implementation(std::forward<P0>(p0))){}

template<typename T>
pimpl<T>::~pimpl(){}

template<typename T>
pimpl<T>::pimpl(const T& other) : impl_(new implementation(*((pimpl&)other).impl_)){}

template<typename T>
pimpl<T>::pimpl(T&& other) : impl_(std::move(((pimpl&)other).impl_)){}

template<typename T>
void pimpl<T>::swap(T& other)
{
    impl_.swap(other.impl_);
}

这就是你如何使用它:

A.h

#include "pimpl.h"

class A : public pimpl<A>
{
    A();
    A(const A& other);
    A(A&& other);
    virtual ~A();
    void foo();
};

A.cpp

#include "A.h"
#include "pimpl_impl.h"

template<>
struct pimpl<A>::implementation
{
     void foo()
     {
     }
};

A::A() : pimpl(){}
A::A(const A& other) : pimpl(other){}
A::A(A&& other) : pimpl(std::move(other)){}
A::~A(){}
void A::foo(){impl_->foo();}

这工作得很好，但是当您将继承放入图片中时，它很快就会崩溃:

class B : public pimpl<B>, public A
{
    ...
};

B::B() : pimpl() {} // pimpl ambiguous

pimpl 变得模棱两可...

关于如何避免这种情况有什么想法吗？

Answer 1

虽然我不建议将 pimpl 塞进 curious base class因为 Liskov，我看不出有任何真正的问题让它发挥作用；

就像@Nim 所建议的那样:做的时候一切似乎都很顺利

class B : public pimpl<B>, public A
{
    B() : pimpl<B>() {} 
};

Gist 已更新，包含适用于 B 的完整示例代码:

• https://gist.github.com/1379569
• 在 http://ideone.com/te49B 上观看直播

B.h

#include "A.h"

class B : public pimpl<B>, public A
{
  public:
    B();
    B(const B& other);
    B(B&& other);
    virtual ~B();
    void bar();
};

B.cpp

#include "pimpl_impl.h"
#include "B.h"

template<>
struct pimpl<B>::implementation
{
     void bar()
     {
     }
};

B::B() : pimpl<B>(){}
B::B(const B& other) : pimpl<B>(other){}
B::B(B&& other) : pimpl<B>(std::move(other)){}
B::~B(){}
void B::bar(){ pimpl<B>::impl_->bar();}

主要.cpp:

#include "B.h"

int main()
{
    A a;
    B b;
}