Question

是否为实现派生类获取基类对象的构造函数而重新实践或其他一些邪恶的软件设计？我需要它在以下Vector / Matrix Framework中。我想只在Matrix类（在operator *中）定义Matrix / Vector乘法的代码一次。但是在Matrix类中，我只能返回抽象基类类型：

// Base
template<class Value_T, unsigned int N>
class VectorT
{
    ...
};

// Derived
class Vector4 : public VectorT<double, 4>
{
public:
    ...
    Vector4(const VectorT<double, 4>& base);    // base class constructor   
    ...
};

// multiplication operator in a matrix class using the abstract VectorT base type
VectorT<value_type, N> operator*(const VectorT<value_type, N>& v) const
{
    VectorT<value_type, N> vRes;
    ...
    return vRes;    // return by value
}

// usage
Vector4 v;
Matrix4 m;

VectorT<double, 4> vMult = m * v;   // this works but is not what I want

Vector4 vMult = m * v;              // this is what I want, but only works with the base class constructor of Vector4

我的主要目标是重复使用矩阵/向量乘法的代码，并在矩阵类中为矩阵类和向量类的所有可能模板规范定义它。

Answer 1

作为T.C.在评论中指出，您甚至不需要让派生类使用Vector4类型。

这是一个3x3乘3的例子：

#include <iostream>

template<class Value_T, unsigned int N>
struct VectorT
{
  VectorT() : data() { }
  Value_T data[N];
};

typedef VectorT<double, 3> Vector_d3;

template < class Value_T, unsigned int N, unsigned int M >
struct MatrixT : VectorT<VectorT<Value_T, M>, N>
{
  VectorT<Value_T, N> operator* (VectorT<Value_T, M> const & v)
  {
    VectorT<Value_T, N> result;
    for (size_t i(0); i < M; ++i)
    {
      for (size_t j(0); j < N; ++j) result.data[i] += data[i].data[j] * v.data[j];
    }
    return result;
  }
};

typedef MatrixT<double, 3, 3> Matrix_d33;

int main()
{
  /*
    m =
    1 2 3 
    4 5 6
    7 8 9
  */
  Matrix_d33 m;
  m.data[0].data[0] = 1;
  m.data[0].data[1] = 2;
  m.data[0].data[2] = 3;
  m.data[1].data[0] = 4;
  m.data[1].data[1] = 5;
  m.data[1].data[2] = 6;
  m.data[2].data[0] = 7;
  m.data[2].data[1] = 8;
  m.data[2].data[2] = 9;
  /*
    v =
    5 4 3
  */
  Vector_d3 v;
  v.data[0] = 5;
  v.data[1] = 4;
  v.data[2] = 3;
  /*
  res =
  1*5 + 2*4 + 3*3 = 22
  4*5 + 5*4 + 6*3 = 58
  7*5 + 8*4 + 9*3 = 94
  */
  Vector_d3 res = m*v;

  std::cout << res.data[0] << std::endl;
  std::cout << res.data[1] << std::endl;
  std::cout << res.data[2] << std::endl;

}

代码打印：

22
58 
94

Answer 2

在派生类对象的构造函数中使用基类对象是一种非常有效的方法。可以将其视为基类部分的复制构造函数和派生类部分的默认构造函数。

来自基类的c ++构造函数

2 个答案: