c++ - Pimpl惯用语中的C++继承

假设我有一个class B和一个从class A : public B继承的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中的父方法？

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

谢谢

编辑:这是示例代码片段-正确吗？

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;
};

最佳答案

如果从B继承了A类，则A应该能够调用B类的接口(interface)。它不必依赖于其实现。

Pimpl-Ideom只是解决C++局限性的一种方法，即不能拆分类的私有(private)， protected 和公共(public)部分的声明。由于您不想向类(class)用户公开类的私有(private)部分，也不想向不想创建子类的用户公开 protected 部分，因此Pimpl-Ideom会将这些部分从头文件移开。

要回答您的问题:

类A必须是子类B，这就是OOP的含义。

类A::impl不需要依赖B::impl即可完成工作。

如果您想走极端，可以设想一个B::protected_impl，其中A::impl可以继承。为此，您必须使用protected_impl声明创建一个单独的头，以便A::impl可以使用它。

关于c++ - Pimpl惯用语中的C++继承，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/43021079/