Pimpl 习语中的 C++ 继承

Question

假设我有一个class B 和一个继承自B 的class A : public B。我要暴露A的方法，调用B中的一些方法。

现在我想在 pimpl 成语中公开这些方法 - 我真的不知道该怎么做：

• A 和 B 是否都获得单独的实现类 B::impl 和 A::impl : public B::impl 以便实现相互继承？然后常规类不会继承：class A 和 class B?

  我意识到这是不可能的，因为实现是 private。

• 实现不会继承 B::impl 和 A::impl，但公开的类会继承 class B 和 class A : public B。但是A::impl中的方法如何能够调用B::impl中父级的方法呢？

• 通过参数中的指针 - 请参见下面的示例。

谢谢

编辑：这是一个示例代码 sn-p - 这是正确的吗？

test.hpp

#include <iostream>

class B {
private:
    class impl;
    std::unique_ptr<impl> pimpl;

public:
    B();
    ~B();
    B(B&&) = default; 
    B(const B&) = delete;
    B& operator=(B&&);
    B& operator=(const B&) = delete;

    void my_func() const;
};

class A : public B {
private:
    class impl;
    std::unique_ptr<impl> pimpl;

public:

    A();
    ~A();
    A(A&&) = default; 
    A(const A&) = delete;
    A& operator=(A&&);
    A& operator=(const A&) = delete;

    void access_my_func();
};

test.cpp

#include "test.hpp"

// Implementation of B
class B::impl
{
public:
    impl() {};

    void impl_my_func() { 
        std::cout << "impl_my_func" << std::endl;
        return; 
    };
};

// Constructor/Destructor of B
B::B() : pimpl{std::make_unique<impl>()} {};
B::~B() = default;
B& B::operator=(B&&) = default;

// Exposed method of B
void B::my_func() const {
    std::cout << "B::my_func" << std::endl;
    pimpl->impl_my_func();
    return; 
};


// Implementation of A
class A::impl
{
public:
    impl() {};

    void impl_access_my_func(const A& a_in) {
        std::cout << "impl_access_my_func" << std::endl;
        a_in.my_func();
        return;
    };
};

// Constructor/Destructor of A
A::A() : pimpl{std::make_unique<impl>()} {};
A::~A() = default;
A& A::operator=(A&&) = default;

// Exposed method of A
void A::access_my_func() {
    std::cout << "A::access_my_func" << std::endl;
    pimpl->impl_access_my_func(*this);
    return;
};




// Later in the main.cpp file
int main() {

    // Make an object
    A my_A_object;
    my_A_object.access_my_func();

    return 0;
};

Answer 1

如果你从 B 继承 A，A 应该能够调用 B 类的接口。它不应该依赖于它的实现。

Pimpl-Ideom 只是一种处理 C++ 限制的方法，您不能拆分类的私有、受保护和公共部分的声明。由于您不想将类的私有部分公开给类用户，也不希望将受保护部分公开给不想子类化的用户，因此 Pimpl-Ideom 将这些部分从头文件中移开。

回答你的问题：

• A 类必须是 B 的子类，这就是 OOP 的意义所在。
• A::impl 类不需要依赖 B::impl 来完成其工作。
• 如果你想走极端，你可以设想一个 B::protected_impl，它可以是 A::impl 的子类。为此，您必须使用 protected_impl 声明创建一个单独的标头，以便 A::impl 可以使用它。