[C++] Classe générique, surcharge d'opérateurs

[invitefba353f4]

Bonjour,

J'ai une classe générique Vector<T> qui représente un vecteur à plusieurs coordonnées. Je voudrais redéfinir les opérateurs d'affectation (=) et d'addition (+) tout en pouvant effectuer ces opérations sur des vecteurs possédant des coordonnées de type différent.
Par exemple : Vector<float> + Vector<int> ou Vector<float> * Vector<int>
Avez-vous des conseils ?

Merci d'avance !
-----

[Paraboloide_Hyperbolique]

Bonsoir,

Voici un petit essai. La fonction suivante effectue l'addition de deux vecteurs de type quelconque (tant que l'opérateur '+' est défini sur ces types) et renvoi la somme sous la forme d'un vecteur de double.

using namespace std;

template<typename Type1, typename Type2>
vector<double> operator+(const vector<Type1> &v1, const vector<Type2> &v2)
{
  vector<double> res;
  typename vector<Type1>::const_iterator it1 = v1.begin();
  typename vector<Type2>::const_iterator it2 = v2.begin();

  for(; it1 != v1.end() && it2 != v2.end(); ++it1, ++it2)
    res.push_back(static_cast<double>(*it1) + static_cast<double>(*it2));

  return res;
}

[invitefba353f4]

Merci !
Mais j'aimerai utilisé plutôt une méthode de cette forme :

template <class T>
Vector<T> operator +(const Vector<T> & v)
{
...
}

C'est possible ?

[Paraboloide_Hyperbolique]

Bonjour,

Oui c'est possible en créant sa propre classe de vecteur qui hérite de std::vector.
Cela devrait être quelque chose du style (à vérifier):

template<class T>
class Vector: public std::vector<T>
{
public:
  template<class OtherType>
  Vector<T> operator+(const Vector<OtherType> &v) const
  { /* Implémentation */ }
};

[A voir en vidéo sur Futura]

[invitecba2e9e4]

hello,

rappelons juste que le destructeur de vector n'est pas virtual, donc il faut éviter d'hériter de vector (et généralement des conteneurs de la stl) et préférer la composition (quitte à ajouter un lvl d'indirection pour chaque méthode nécessaire de vector)

[invitecba2e9e4]

Un exemple (discutable) en réutilisant valarray

#include <valarray>
#include <iostream>

template<typename Out>
struct Caster{
  template<typename In>
  Out operator()(const In &iIn)const{
    Out val;
    val+=iIn;
    return val;
  }
};
template<>
struct Caster<int>{
  template<typename In>
  int operator()(const In &iIn)const{
    int val(0);
    val+=iIn;
    return val;
  }
};
template<typename T, int N, typename Cast=Caster<T> >
class Vector{
public:
  Vector():_v(N),_caster(Cast()){};
  template<typename Other>
  Vector<T,N> operator+(const Other& iOther)const{
    Vector<T,N> v, aOther;
    v._v+=_v;
    for(size_t i=0;i<N;++i){
      aOther._v[i]=_caster(iOther._v[i]);
    }
    v._v+=aOther._v;
    return v;
  }
  T sum()const{
    return _v.sum();
  }
  T& operator[](size_t index){
    return _v[index];
  }
  std::valarray<T> _v;
  Cast _caster;
};
int main(){
  Vector<std::string,2> v;
  v[0]="qua";
  v[1]="ante deu";
  Vector<char,2> v2;
  v2[0]='r';
  v2[1]='x';
  Vector<std::string,2> v3 = v+v2;
  std::cout<<v3.sum()<<std::endl;
  
  
  Vector<int,2> a;
  Vector<double,2> b;
  a[0]=10;b[0]=7;
  a[1]=15;b[1]=10;
  Vector<int,2> c=a+b;
  std::cout<<c.sum()<<std::endl;
  return 0;
}