Question

我有以下情况：

class num {
    public:
    void print(ostream* o); // Prints the n variable
};

class int_num : public num{
    public:
    int n; // Initialized by this class's constructor
};

class float_num : public num{
    public:
    float n; // Initialized by this class's constructor
};

class double_num : public num{
    public:
    double n; // Initialized by this class's constructor
};

我如何实施这样的计划

Answer 1

给它一个虚拟方法，在派生类型中实现：

class num {
 public:
    void print(ostream& o) const
    {  // Prints the n variable
      doPrint(o);
    }
 private:
    virtual void doPrint(ostream& os) const = 0;
};

class double_num : public num{
  public:
    double n; // Initialized by this class's constructor
 private:
  void doPrint(ostream& os) const 
  {
    os << n;
  }
};

Answer 2

为什么不使用template：

template<typename T>
class num
{
    T n;  //data of type T

 public:

      //add constructor(s) to initialize n

      void print(std::ostream &out) { out << n ; }

      //add functions(s) to work with n
};

可以进行打印。

现在您有两个选择：

如果代码中的所有派生类型都做同样的事情，则使用typedef，没有特定类型：

//use typedefs
typedef num<int>    int_num; 
typedef num<float>  float_num; 
typedef num<double> double_num;

或者使用继承如果您需要在派生类中执行 type 特定的事情：
```
class int_num : public num<int>
{
   //int specific things 
};
```

关键是num<T>可以进行打印，无论您使用的是typedef还是继承。

Answer 3

您有两种选择。

一个是使print()纯虚拟并在派生类中实现它，正如其他人已经指出的那样。

另一种选择是使用Curiously recurring template pattern，如下所示：

template <typename Impl>
class num
{
public:
  void print(ostream &os) const
  {
    os << static_cast<const Impl*>(this)->n;
  }
};

class int_num : public num<int_num>
{
  //same as before
};

class float_num : public num<float_num>
{
  //same as before
};

//etc.

Answer 4

有两种解决方案。第一种方法是使print方法成为一种纯抽象方法，并在所有子类中实现它。第二种是使用模板：

template<typename T>
class num
{
public:
    void print(std::ostream& os) const
        {
            os << num_;
        }

private:
    T num_;
};

typedef num<float> float_num;
typedef num<int>     int_num;

访问派生类成员的基类方法

4 个答案: