Új hozzászólás Aktív témák

• #2843 jattila48 aktív tag Boryszka #2831

  Új Válasz 2015-11-09 13:10:32 #2843

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  jattila48

  aktív tag

  válasz Boryszka #2831 üzenetére

  A matrix_base-től való öröklés szerintem felesleges, főleg private módon. A következő header jó kiindulás lehet:

  template<typename T,int n,int m> class my_matrix{
  public:
  typedef T scalar_type;
  /*
  my_matrix(const my_matrix& mm){
  int i,j;
  for(int i=0;i<n;++i){
  for(j=0j<m;++j){
  matrix[i][j]=mm[i][j];
  }
  }
  }
  my_matrix &operator=(const my_matrix &mm){
  
  }
  */
  my_matrix(){
  int i,j;
  for(i=0;i<n;++i){
  for(j=0;j<m;++j){
  matrix[i][j]=T();
  }
  }
  }
  
  my_matrix & operator+=(const my_matrix &mm){
  int i,j;
  for(i=0;i<n;++i){
  for(j=0;j<m;++j){
  matrix[i][j]+=mm.matrix[i][j];
  }
  }
  return *this;
  }
  
  my_matrix & operator*=(T c){
  int i,j;
  for(i=0;i<n;++i){
  for(j=0;j<m;++j){
  matrix[i][j]*=c;
  }
  }
  return *this;
  }
  
  my_matrix operator+(const my_matrix &mm){
  my_matrix t(*this);
  int i,j;
  for(i=0;i<n;++i){
  for(j=0;j<m;++j){
  t.matrix[i][j]+=mm.matrix[i][j];
  }
  }
  return t;
  }
  
  my_matrix & operator=(const my_matrix &mm){
  int i,j;
  for(i=0;i<n;++i){
  for(j=0;j<m;++j){
  matrix[i][j]-=mm.matrix[i][j];
  }
  }
  return *this;
  }
  const T & operator()(int i,int j) const{
  assert(i<n && j<m);
  return matrix[i][j];
  }
  
  T & operator()(int i,int j){
  return const_cast<T &>(const_cast<const my_matrix *>(this)->operator()(i,j));
  }
  private:
  my_matrix(const my_matrix &a,const my_matrix &b){
  int i,j;
  for(i=0;i<n;++i){
  for(j=0;j<m;++j){
  matrix[i][j]=a.matrix[i][j]+b.matrix[i][j];
  }
  }
  }
  T matrix[n][m];
  };
  /*
  template<typename T> T operator+(T a, T b){
  T c(a);
  c+=a;
  return c;
  }
  */
  template<typename T,int n,int m,int k> my_matrix<T,n,m> operator*(const my_matrix<T,n,k> &a,const my_matrix<T,k,m> &b){
  my_matrix<T,n,m> c;
  int i,j,l;
  for(i=0;i<n;++i){
  for(j=0;j<m;++j){
  T s=T();
  for(l=0;l<k;++l){
  s+=a(i,l)*b(l,j);
  }
  c(i,j)=s;
  }
  }
  return c;
  }
  
  template<typename T> T operator*(T A,typename T::scalar_type c){
  T t(A);
  t*=c;
  return t;
  }
  
  template<typename T> T operator*(typename T::scalar_type c,T A){
  return operator*(A,c);
  }

  Copy ctor-t és értékadó operátort csak akkor kell írnod, ha a scalar_type (a mátrix elemeinek típusa) nem triviálisan másolható. Ezt pl. type trait-tal is ellenőrizheted. A + operator lehet tfv. is, ha nincs más típusról implicit konverzió. Különben free fv.-nek kell lenni. Én most nem írtam 1 paraméteres ctort, így nem lehet implicit konverzió (kivéve, ha más osztálynak van my_matrix-ra konverziós operátora).

Új hozzászólás Aktív témák