私有继承时如何在子类型之间进行转换

Question

考虑这段 C++ 代码：

template <typename T>
struct Implementation
{ 
    // data members ...

    // conversion constructors:
    template <typename U>
    Implementation(const Implementation<U>& other) : n(other.n) { /* ... */ }
};

template <typename T>
struct Interface : private Implementation<T>
{
    // no data members!

    // this would not work because of private inheritance:
    // template <typename U>
    // Interface(const Interface<U>& other) : Implementation<T>(other) {}

};

实现

Interface

不同实例之间转换的最佳方法是什么？

显然，可以让所有接口成为朋友：

    template <typename U>
    friend struct Interface;

但这似乎很危险而且没有必要。更好的方法是：

template <typename T>
struct Interface : private Implementation<T>
{
    // publicly exposed conversion from Implementation
    explicit Interface(const Implementation<T>& other)
        : Implementation<T>(other) {}

    template <typename U>
    operator Interface<U>() const {
        return static_cast<Interface<U>>(static_cast<Implementation<U>>(*this));
    }
};

但这也需要扩展公共接口，这可能并不理想。有更好的方法吗？

Answer 1

我认为你的做法是错误的。当您开始需要在动态多态（继承虚拟方法）用例中进行强制转换（例如尝试实现或从接口继承）时，您可能做错了什么。

所以我同意 Marek 的观点，我怀疑你需要这样的东西。

#include <iostream>

class Interface
{
public:
    virtual ~Interface() = default;
    virtual void DoSomething() = 0;
};

// Reusable interface implementation
template<class Derived>
class InterfaceImplementation :   Interface
{
public: 
    void DoSomething() override
    {
        std::cout << "DoSomething for " << typeid(Derived).name() << "\n";
    }
};

class A : 
    public InterfaceImplementation<A>
{
};

class B :
    public InterfaceImplementation<B>
{
};


int main()
{
    A a;
    B b;

    a.DoSomething();
    b.DoSomething();
}