问题

Question

假设我有以下带有2个构造函数的Abstract类：

#ifndef ABSTRACTCLASS_H
#define ABSTRACTCLASS_H

#include <iostream>

using namespace std;

class AbstractClass
{
    public:
      AbstractClass(int);
      AbstractClass();
      virtual ~AbstractContext();
      //Pure virtual function
      virtual void doSomething() = 0;

    private:
        int  x;
};

#endif

我有2个类将继承自AbstractClass。

A类将使用AbstractClass(int);
B类将使用AbstractClass();

#ifndef A_H
#define A_H

class A: public AbstractClass
{
    public:
     A(int = 0);
     virtual ~A();
     virtual void doSomething();
    private:
     int xCoord;
}

#endif

A.cpp
#include "A.H"
A::A(int x):AbstractClass(x),xCoord(x) {}

void A::doSomething()
{
  cout << xCoord * xCoord << endl;
}

#ifndef B_H
#define B_H

    class B: public AbstractClass
    {
        public:
         B();
         virtual ~B();
         virtual void doSomething();
    }

    #endif

    B.cpp
    #include "B.H"
    B::B():AbstractClass() {}

    void B::doSomething()
    {
      cout << "nothing" << endl;
    }

问题

我在抽象类中使用2个构造函数是一个好习惯吗？
遗产是否正确？特别是我正在使用2个版本的构造函数？

Answer 1

如果这两个构造函数都可以应用于从ABC派生的（或将是一天）的每个类型，那么拥有一个具有多个public构造函数的ABC是完全合适的。

也就是说，public基类构造函数仍然是类接口的一部分。如果这些构造函数中的一个或多个不适用于每个具体实例化，那么理想情况下它们不应该是public接口的一部分。使那些特殊的构造函数private是一种改进，因为未来的程序员更难以错误地实现新的具体派生类型。

这是其他创作模式发挥作用的时候。一种常见且简单的方法是在ABC上提供static个成员函数来创建具体类型。这是factory method模式的一个示例。

class A;
class B;

class AbstractClass 
{
public:
  static std::unique_ptr <AbstractClass> MakeA (int x)
  { 
    return std::make_unique <A> (x);  // You need to provide this, easily found
  }

  static std::unique_ptr <AbstractClass> MakeB ()
  {
    return std::m,ake_unique <B> ();
  }
  virtual ~AbstractClass();

private:
  AbstractClass ();
  AbstractClass (int x);
};

有many other个创作模式;这在我看来是最直观的。

Answer 2

这没什么不对。

您的基类有两种初始化方法，派生类使用最适合其实现的方法。同样，他们可以选择提供自己的两个构造函数，映射到基类中的构造函数。

关键是两个构造函数都应该使类处于合理状态。因此，例如，基类中的默认构造函数应该将xCoord设置为某个合理值（可能为0），而我猜测AbstractClass(int)正在将xCoord设置为值传递给构造函数。

带有两个构造函数的抽象类c ++

问题

2 个答案: