Question

类伪定义：

基本虚拟A类：

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

B类继承自A：

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

基本虚拟C类：

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

D类继承自C：

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

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

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

1 个答案: