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

Posted 2023-02-23

【中文标题】来自基类的 c++ 构造函数

【英文标题】：c++ constructor from base class

【发布时间】：2014-06-11 15:26:21

【问题描述】：

为派生类实现构造函数获取基类对象是回溯实践还是其他某种邪恶的软件设计？ 我在以下向量/矩阵框架中需要它。我只想在 Matrix 类中（在 operator* 中）定义一次矩阵/向量乘法的代码。但在 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

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

【问题讨论】：

如果Vector4 没有在VectorT 之外做任何事情，只需使用typedef：typedef VectorT<double, 4> Vector4;（或在C++11 中键入别名：using Vector4 = VectorT<double, 4>;）

与您的问题无关，但您的矩阵总是 NxN 吗？如果没有，你应该改用VectorT<value_type, M> operator*(const VectorT<value_type, N>& v);

感谢提示，typedef 是一个直接的解决方案，但实际上我的 Vector4 类有一些特定的行为。

@Erbureth：是的，我只需要二次矩阵，因此它们都是 NxN。

【参考方案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

【参考方案2】：

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