c++ - 将对成员的引用传递给基类的构造函数

Question

我已经创建了一个依赖注入(inject)，其中 A 依赖于 IB 和 B1 实现 IB。对于一个非常具体的情况，我想创建一个类 C : A ，它不会暴露依赖注入(inject)。我要:

1. C 构造依赖并将其传递给它的基类 A 优雅地处理依赖的生命周期
2. C 毫不费力地向用户公开 A 的公共(public)方法

class IB
{
    public:
        virtual void InterfaceCall() = 0;
        /* ... */
}

class B1 : IB
{
    public:
        void IntefaceCall();
        /* ... */
}

class A
{
    public:
        A(IB& ib);
}

// for a specific case I would like to use class A and all it's logic and public methods, but remove dependency injection
class C : A
{
    B1 b1;
    public:
        C()
        : A(b1)
        , b1() // the order of initialization list is determined by standard
        {}
}

这是否可能，或者我是否需要放弃我对 C 的要求之一？

Answer 1

如果A，我相信这是合式的构造函数实际上并不使用引用访问任何成员。

编辑: A的析构函数也不能使用引用的任何成员，因为值将以相反的顺序被破坏(首先是 b1，然后是继承的 A)。

您可以在不知道 A 如何实现的情况下确保其格式正确构造函数和/或析构函数可以通过控制初始化顺序来使用引用。您可以通过继承提供 b1 的另一种类型来做到这一点从 A 继承之前的成员.

这是我们将从中继承的类型:

// C++03 version
template <typename T, typename = void>
struct member
{
    T value;
};

// C++11 version
template <typename T, typename = void>
struct member
{
    T value;

    template <typename... Args>
    member(Args && ...a) : value{std::forward<Args>(a)...} { }
};

然后我们将有C在继承之前私下继承A :

class IB
{
    public:
        virtual void InterfaceCall() = 0;
};

class B1 : public IB
{
    public:
        B1() { std::cout << "constructed B1 " << static_cast<void *>(this) << '\n'; }

        virtual void InterfaceCall() { }
};

class A
{
    public:
        A(IB & ib) { std::cout << "constructed A with B1 " << static_cast<void *>(&ib) << '\n'; }
};

class C : private member<B1>, public A
{
    // For convenience, if you need to use the B1 object in C.  If not, you
    // can omit this reference.    
    B1 & b1;

    public:
        C() :
            member<B1>(), // Implied
            A(member<B1>::value),
            b1(member<B1>::value) { }
};

证明初始化顺序正确的示例输出:

constructed B1 0x7ffe691b9710
constructed A with B1 0x7ffe691b9710

( Demo )

---

注意 member 的第二个参数template 是一个标签，如果需要，它允许您使用此技术来控制同一类型的多个成员的初始化顺序。例如，class foo : member<B1, TagA>, member<B1, TagB> .