Dans un .hpp pour multiplier un scalaire T1 et un vecteur dans T2 :

#include <vector>

template <typename T1,typename T2>
std::vector<T2> operator*(const T1 & x,const std::vector<T2> & y){
  std::vector<T2> z(y.size());
  for(std::size_t i=0;i<n;++i) z[i] = x * y[i];
  return z;
}

Bonjour,
Essaye comme ceci

Vector operator * (float f,Vector v)

et ca réciproque :

Vector operator * (Vector v, float f)

(Pour info : http://www-ipst.u-strasbg.fr/pat/program/cpp/vecteur-simple.­pdf) -- Alex pour vous servir --

-- N'oubliez pas de mettre vos sujets en "Résolu" lorsque vous avez la réponse ;-) --

Bien que résolu je me permets de revenir sur le sujet car ce qu'à dit est faux (tu peux tout à fait implémenter * sur un vecteur), parce que tassin a dit un cas particulier de ce que j'ai donné, et parce que manifestement le code que je t'ai donné n'est pas clair.

Un exemple plus parlant

On va enrichir ce que j'ai donné en <1> pour illustrer l'utilisation (accessoirement rajouter l'instruction en gras qui manquait)

#include <vector>
#include <ostream>
#include <iostream>

template <typename T1,typename T2>
std::vector<T2> operator*(const T1 & x,const std::vector<T2> & y){
    const std::size_t n = y.size();
    std::vector<T2> z(n);
    for(std::size_t i=0;i<n;++i) z[i] = x * y[i];
    return z;
}

template <typename T>
std::ostream & operator<<(std::ostream & out,const std::vector<T> & x){
    const std::size_t n = x.size();
    for(std::size_t i=0;i<n;++i) out << x[i] << ' ';
    return out;
}

int main(){
    std::cout << "vecteur v" << std::endl;
    std::vector<int> v(5);
    v[0] = 1; v[1] = 3; v[2] = 4; v[3] = 2; v[4] = 7;
    std::cout << v << std::endl;
    std::cout << (2*v) << std::endl;
    std::cout << (3.1*v) << std::endl;

    std::cout << "vecteur w" << std::endl;
    std::vector<double> w(5);
    w[0] = 1; w[1] = 3; w[2] = 4; w[3] = 2; w[4] = 7;
    std::cout << w << std::endl;
    std::cout << (2*w) << std::endl;
    std::cout << (3.1*w) << std::endl;
    return 0;
}

vecteur v
1 3 4 2 7
2 6 8 4 14
3 9 12 6 21
vecteur w
1 3 4 2 7
2 6 8 4 14
3.1 9.3 12.4 6.2 21.7

#include <iostream>

class plop_t{
    protected:
        unsigned x;
    public:
        plop_t(unsigned x0):x(x0){}

        unsigned get_x() const{
            return x;
        }

        unsigned operator + (const unsigned y) const{
            return x + y; // j'ai accès à x car je suis dans la classe
        }
};

unsigned operator *(const plop_t & p,const unsigned y){
    return p.get_x() * y; // je n'ai pas accès à x (protégé)
}


int main(){
    plop_t p(69);
    std::cout << (p + 1) << std::endl;
    std::cout << (p * 2) << std::endl;
    return 0;
}

70
138

Il ne faut pas que ce soit une méthode de ta classe Vector mais une fonction et une fonction friend de sucroit.

C'est juste cette phrase qui me dérangeait car :

1- c'est la classe std::vector (au lieu de Vector)

2- elle peut être méthode de std::vector si on s'autorise à modifier l'implémentation de cette classe (ou si on fait un héritage) si on veut écrire l'opérateur dans la classe

3- dans le cas particulier de std::vector on n'a de toute façon pas besoin d'accéder à des membres privés ou protégés pour ce genre d'opération (du moins tout est accessible via des accesseurs genre []), donc pas besoin de friend. On peut donc implémenter l'opérateur hors de la classe indiqué dans <6>. Bien que l'implémentation soit en dehors de la classe std::vector, elle est équivalente à une implémentation à l'intérieur de la classe elle-même.

Mais désolée je pinaille :p

Ah ok je vois ce que tu veux dire. En fait tel qu'il a présenté son problème, je pensais qu'il recodait la classe Vector en cours de prog. Donc pour moi il partait de zero et n'utilisait pas la librarie standard (cf message 2).

Mais tu as raison de pinailler, c'est vrai que je suis dans le faux en disant qu'il faut que l'operator soit implémenté à l'extérieur. Ce que je voulais signifier, c'était plus exactement que cet operator devait être une fonction et non pas une méthode. Ensuite par habitude je rajoutais qu'il faut que l'implémentation soit à l'extérieur, mais c'est finalement plus un tic de propreté qu'une necessité :-)

A bientôt :-)

Pas de souçis ;-)