1 
struct Base {
  Base (type1, type2, type3);
  Base (); // <--- should be invoked only by `Derived_2`
  virtual ~Base() = 0;  // an abstract class
};

上面说Base，我们有多个派生类：Derived_1, Derived_2, ..., Derived_N。

在构造对象时，所有派生类都必须调用Base(type1, type2, type3)构造函数， except Derived_2，在构造对象时应该使用Base()（默认构造函数）。

有没有办法（C++ 11 可以）有这样的规则？换句话说，如果除了Derived_2尝试使用默认的无参数构造函数之外的任何人，编译器应该给出一个错误。

编辑：对于那些询问设计问题的人，我同意这一点。这是我的看法。

  • 实际上，理想情况下我根本不想要默认构造函数。所有都必须使用带参数的构造函数，它 以type1, type2, type3.
  • 现在，我看到继承层次结构中的几个类，其对象将在main()执行之前全局实例化。当然，这些都是特殊情况，必须通过引入默认构造函数来娱乐它们
  • 然而，这种治疗仅适用于 1 类或最多 2 类。其余所有类都必须维护调用参数构造函数的规则。

我希望这能说明这个想法。

4

4 回答 4

7

我能想到的唯一方法是将你Base的默认构造函数声明为私有并Derived_2与你的类成为朋友Base，这样它就可以调用它的默认构造函数。

然而，这种风格是可怕的，因为你的Base类现在必须知道它的派生类之一。并且仍然可以Dervived_2使用 3 个参数调用构造函数。

于 2013-05-01T06:47:22.283 回答
4

我将介绍另一个级别的推导：

        Base
         ^
         |
   +-----+------+
   |            |
Derived2    BaseWithParams
              ^         ^
              |         |
           Derived1    DerivedN

在基础中，您实现了无状态或默认状态（在我看来，拥有默认状态是有意义的，因为这就是Derived2应该这样做的原因）。

struct Base
{
    virtual ~Base() = 0;
};
struct Derived2 : public Base
{
    Derived2() {}          // Do default initialization
    virtual ~Derived2() {} // Implement destructor so it's not pure virtual anymore
};
struct BaseWithCtor : public Base
{
    BaseWithCtor(type1, type2, type3) {}
    // Do not implement destructor, leave the class abstract
};
于 2013-05-01T07:53:07.453 回答
2

将默认构造函数设为私有，并将 Derived_2 声明为友元：

class Derived_2;

class Base { 
    Base();
public:
    Base(int, int, int);
    virtual ~Base() = 0;
    friend class Derived_2;
};

class Derived_1 : public Base { 
public:
    Derived_1() : Base(1, 2, 3) {}
};

class Derived_1a : public Base { 
public:
    Derived_1() {} // will fail: Base::Base() not accessible
};


class Derived_2 :public Base { 
public:
   ~Derived_2() {}
};
于 2013-05-01T06:45:48.093 回答
0

当您编写派生类时，只有在第二个派生类中您应该调用默认的基本构造函数，其余部分您可以调用参数化构造函数。

      class derived1{             
                     derived1(): base(type1, type2, type3){}

                     };

       class derived2{
                      derived2(): base(){}
                      };
        class derived3{             
                     derived3(): base(type1, type2, type3){}

                     };
       class derived4{             
                     derived4(): base(type1, type2, type3){}

                     };

`

等等。对于其余的课程。另外......这是oop，您制作课程，以便您自己决定课程的行为。因此，您只需确保在派生类的任何地方都没有显式调用基类的默认构造函数。每次需要调用构造函数时，都在派生类中调用参数化的构造函数，因为毕竟，您可以控制类的工作。

于 2013-05-01T08:52:55.307 回答