构造函数中的引用初始化问题

Question

类伪定义：

基础虚拟类 A：

class A {
public:
    virtual ~A();
    virtual void doSomething() const = 0;
};

从 A 继承的 B 类：

class B : public A {
public:
    void doSomething() {} const;
}

基础虚拟类 C：

class C {
public:
    virtual ~C();
    virtual void doSomething() const = 0;
};

从 C 继承的 D 类：

class D : public C {
public:
    D(const &A _a = *A_Ptr(new B)) : a(_a) {}
    void doSomething() {} const;
private:
    const &A a;
}

A_Ptr 是 A 类共享指针的 typedef。

我的问题是声明另一个类。

我们称之为 X 类：

class X {
public:
    X(const &A _a = *A_Ptr(new B), const &C _c = *C_Ptr(new D(a)) : a(_a), c(_c) {}
private:
    const &A a;
    const &C c;
}

X(const &A _a = *A_Ptr(new B), const &C _c = *C_Ptr(new D(a)) - 这部分初始化不起作用。什么工作是

X(const &A _a = *A_Ptr(new B), const &C _c = *C_Ptr(new D)

但如果我这样做，我会创建两个 A 类类型的共享指针，这不是我想要的。另一方面，X(const &A _a = *A_Ptr(new B), const &C _c = *C_Ptr(new D(a)) 或 X(const &A _a = *A_Ptr(new B), const &C _c = *C_Ptr(new D(_a)) 之类的任何东西都不起作用。有没有已知的方法来解决这个问题？

提前致谢：)

Answer 1

如果我理解正确，您需要一个使用外部资源或管理自己的资源的类。如果是这种情况，您必须允许班级两者都做。我相信它可以像这样工作：

class D : public C {
public:
    D() : myA(new B), a(*myA) {}
    D(const &A _a) : a(_a) {}
    void doSomething() {} const;
private:
    std::unique_ptr<A> myA;
    const &A a;
}

这样，D 可以在没有参数的情况下创建，并且将正确管理绑定到a 的对象的生命周期，或者可以使用外部提供的A 创建它，并且不会自己创建任何东西。

可以对X进行类似的更改：

class X {
public:
    X() : myA(new B), a(*myA), myC(new D(a)), c(*myC) {}
    X(const &A _a) : a(_a), myC(new D(a)), c(*myC) {}
    X(const &A _a, const &C _c) : a(_a), c(_c) {}
private:
    std::unique_ptr<A> myA;
    const &A a;
    std::unique_ptr<C> myC;
    const &C c;
}

请注意，您的原始代码有悬挂引用，因为当构造函数运行完成时，作为默认参数创建的智能指针超出范围。这就是为什么它们必须存储在类中的某个位置，就像上面的解决方案一样。