C ++ constructor from the base class

Question

Is the practice or some other design of malicious software true for implementing a constructor for a derived class receiving an object of a base class? I need this in the following vector / matrix structure. I want to define the code for matrix / vector multiplication only once - in the Matrix class (in the * operator). But in the Matrix class, I can only return the abstract type of the base class:

// 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

My main goal is to reuse the matrix / vector multiplication code and therefore define it in the matrix class for all possible specifications of the template matrix classes Matrix and Vector.

Answer 1

. .

Answer 2

T.C. , Vector4.

3 × 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