C++避免构造对象

C++ avoid constructing an object

本文关键字：对象 C++      更新时间：2023-10-16

我有一个类，它的所有默认构造函数都超出了我的控制范围。我需要避免在某些条件下构建它们，而不是在其他条件下构建它们。我能做什么吗？

模式是这样的：

class A
{
public: 
    //ctor + dtor + methods
    A(); 
    ~A();
    // Data members beyond my control
    X1 x1;
    X2 x2;
    ...
    XN xn;
};
class B
{
public:
    B()
    {}
    // Data members
    A a;   // This instance of A is the issue
};

这个问题X1 XN完全超出了我的控制范围。类 A 只是一个将x1打包在一起xn的类。我想有条件地创建A的实例，在B.现在的问题是，X1的默认构造函数XN做一些在某些情况下需要避免的事情，而不是其他条件。因此，无论我是否构造A，B都会尝试使用默认构造函数创建一个A，这反过来又会启动X1的默认构造函数XN。这是我需要避免的。

我目前正在使用宏来解决此问题，但想看看是否有更好的解决方案。

正如康拉德·鲁道夫(Konrad Rudolph(指出的那样：

class B
{
public:
  B(bool create = false)
  {
    a = (create ? new A : NULL);
  }
  ~B()
  {
    delete a;
  }
private:
  A* a;
};

你可能想要使用一个可为空的类型，如 boost：：optional。这看起来像：

class B {
public:
    B()
    {
        /*
         * Here, a has been default constructed and is empty
         * You can do computations here and then...
         */
        if(/* some elaborate condition*/) {
            a = A();
            /* access *a from here on */
        } else {
            /* anything you want */
        }
    }
private:
    boost::optional<A> a;
};

这回答了这个问题，但我认为如果你告诉你真正想要实现的目标，可以给出一个更合适的答案。我觉得这更像是一个设计问题，而不是语言问题。接下来是延伸的思想。

在上述"解决方案"中，else条款中的内容是什么？由于A显然只能是默认构造的，因此您不能放置不同的构造函数调用。但是，如果您不初始化a则会引入(圈(复杂性，因为这意味着每个方法都必须检查a是否处于活动状态。或者你可以扔;但是，我会重构在函数中进行检查(或其他任何操作(的代码;私有静态方法或匿名/静态独立函数如下所示：

namespace {
A
prepare_A()
{
    /* elaborate computations, possibly throw */
    return A();
    /*
     * if A had different constructors we could also conditionally
     * return an A(0) or whatever.
     */
}
} // namespace
B::B()
:
    a(prepare_A())
{
    /*
     * a is of type A, not boost::optional<A>
     */
}

但是，这假定A是可复制的。如果不是这种情况，或者复制A是不可接受的，我认为第一个解决方案是可以接受的，条件是作为类不变的一部分，a永远不会为空。

如果我们知道A和B之间的关系，推荐一些东西会更容易。如果要有条件地初始化 A 成员，为什么要将其放入B？也许两者之间的首选关系不应该是聚合，而应该是关联：指针成员(或引用成员，如果你小心赋值运算符(到A，例如：

class B {
public:
    explicit
    B(A& a_)
    /*
     * Important: not A const&,
     * we only want lvalues.
     * Contract on the caller: a must remain valid during
     * the lifetime of *this.
     */
    :
        a(&a_)
    {
        /*
         * class invariants: a != 0,
         * *a remains valid for the lifetime of B
         */
    }
private:
    A* a;
};

这样你就不会引入圈复杂性，也不关心如何以及何时构造 A。合约给调用者增加了一点负担，但由于我们只能将 lvalue 传递给构造函数，因此很难(er(滥用。

目前还不清楚要避免使用哪个构造函数，但无论哪种情况，您都可以使用联合。

来自斯特劳斯特鲁普第4版：

如果联合具有具有用户定义的构造函数、复制操作、移动操作或析构函数的成员，则将删除该联合的特殊函数 (§3.3.4， §17.6.4(;也就是说，它不能用于联合类型的对象。

因此，如果您不想在 B 中构造 A，请使用：

class B {
public:
    B()
    {}
    // Data members
    union {
       A a;   // This instance of A is the issue
    };
};
相关文章：