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

• #2375 Jester01 veterán KPepe #2373

  Új Válasz 2006-12-07 02:25:06 #2375

  Ú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

  

  Jester01

  veterán

  válasz KPepe #2373 üzenetére

  Ez a kód olyan mintha a haverom írta volna Ész nélkül kihasználja a nyelvben lévõ lehetõségeket, de feláldozza az olvashatóságot és karbantarthatóságot. Kiváló példája annak, hogyan ne használjuk a template-eket, hacsak nem vagyunk zsenik.
  
  Mindenesetre a dolog kb. a következõképpen mûködik:
  Vektorokkal végez mûveleteket, ez gondolom nyilvánvaló. A Vector<T, N> N darab T típusú elemet tartalmaz. A VectorSum osztály az összeadás mûveletet reprezentálja.
  
  Az elsõ összeadás operátor azt írja le, hogy két azonos elemtípusú és méretû vektor összeadható, és az eredménye ugyancsak ilyen tulajdonságú vektor lesz.
  
  A második összeadás operátor azt mondja, hogy egy vektorösszeghez jobbról még hozzá lehet adni egy másik vektort is.
  
  Az init és print függvények gondolom világosak.
  
  A megvalósítandó mûveletek:
  
  vektor + vektorösszeg: a vektorösszeg + vektor mûvelet párja, a jobb és bal oldal felcserélésével.
  
  vektorösszeg + vektorösszeg: mint az elõzõ, csak most mindkét oldal vektorösszeg
  
  számmal szorzás jobbról és balról: be kell vezetni egy új alapmûveletet a VectorSum mintájára, pl. így:
  
  template<class T, long N, class V>
  class ScaledVector
  {
  long factor;
  const V &vector;
  public:
  ScaledVector(long f, const V &v) : factor(f), vector(v) {}
  T operator[](long i) const {
  return factor * vector[ i ];
  }
  };
  
  Igényesebb kollegák a faktor típusát beadhatják template paraméternek, akkor majd pl. double típussal is lehet szorozni.
  
  A Vector osztályba fel kell venni egy újabb overloadot az = operátorra, hogy ilyen ScaledVector osztályt is tudjon fogadni (ugyanúgy sima elemmásolás van benne).
  
  Ezután már csak a szorzás operátorra kell egy overload, pl. így:
  
  template<class T, long N>
  inline ScaledVector<T,N,Vector<T,N> >
  operator*(int f, const Vector<T,N> &v) {
  return ScaledVector<T,N,Vector<T,N> >(f,v);
  }
  
  Illetve hasonlóképpen jobbról való szorzáshoz is.
  
  És mivel ilyen ScaledVector objektumokat még össze is akarunk adni, hát ahhoz rá kell engedni a VectorSum-ot két ScaledVector-ra, imígyen:
  
  template<class T, long N, class Left, class Right>
  inline VectorSum<T,N,ScaledVector<T,N,Left>,ScaledVector<T,N,Right> >
  operator+(const ScaledVector<T,N,Left> &l, const ScaledVector<T,N,Right> &r) {
  return VectorSum<T,N,ScaledVector<T,N,Left>,ScaledVector<T,N,Right> >(l,r);
  }
  
  Egyszerû, nem igaz?
  
  [Szerkesztve]

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