Discussion :

[boutor]

Bonjour à tous,

Après de nombreuses recherches infructueuses sur le sujet (mauvais mots clefs?), je pose ici ma première question.

Je cherche à réaliser la division et multiplication d'un std::vector par un double. Et je commence à devenir fou!

Voici un code restreint qui... ne fonctionne pas.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
#include <iostream>
#include <vector>
 
template< typename T>
void show(std::vector< T > A)
{
    for(std::size_t i = 0; i < A.size(); ++i) {
        std::cout << A[i] << std::endl;
    }
}
 
template< typename T>
std::vector<T>& operator*(const T& a, std::vector<T> B)
{
    for(std::size_t i = 0; i < B.size(); ++i) {
        B[i] = a*B[i];
    }
    return B;
}
 
 
 
int main()
{
    std::cout << "Hello world!" << std::endl;
 
    std::vector<int> A(5), B;
 
    for(std::size_t i = 0; i < A.size(); ++i) {
        A[i] = (int)i;
    }
    std::cout << " A = " << std::endl;
    show(A);
    B = A;
    A = 5 * B;
 
    std::cout << " 5*A = " << std::endl;
    show(A);
 
    std::cout << " B = " << std::endl;
    show(B);
 
 
    return 0;
}

J'obtiens le bon résultat, mais le warning me semble dangereux.

D:\vector_overload\main.cpp||In function 'std::vector<T>& operator*(const T&, std::vector<T>) [with T = int]'
D:\vector_overload\main.cpp:35|13|instantiated from here|
D:\vector_overload\main.cpp|13|warning: reference to local variable 'B' returned|
||=== Build finished: 0 errors, 1 warnings ===|

Je suis sous code::blocks avec MINGW.

J'essaie aussi de faire l'opérateur *=, mais c'est encore pire!

Merci à tous.

[valAa]

Hello,

Ton warning :
Ta fonction prend un paramètre B par valeur.
Elle effectue donc une copie locale de B, modifie cette copie, et renvoie une référence sur cette copie locale.

En sortie de fonction, ta copie locale de B est détruite et donc la référence renvoyée pointe vers... *kaboum* ?

J'aurais plutôt vu un prototype de la forme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
std::vector<T> operator*(const T& a, const std::vector<T>& B)

Mais je peux me planter.

[boutor]

Oui c'est pour ça que je veux trouver le moyen de me débarrasser de ce warning. J'aurais bien aimé utiliser *this; mais je suis en dehors de la class.

J'aurais plutôt vu un prototype de la forme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
std::vector<T> operator*(const T& a, const std::vector<T>& B)

Mais je peux me planter.

le & ne sert-il pas à rendre a et B modifiable par la fonction? Ce que je ne souhaite pas.

[Joel F]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
template<class > vector<T>
operator*( double a, vector<T> const& b)
{
  vector<T> tmp(b);
  for(size_t i=0;i<tmp.size();++i) tmp[i] *= a;
  return tmp;
}

- prendre les argument par reference constantes pour eviter les copies
- les operateur libres renvoient de nouveaux vector pas des references a des temporaires.

[koala01]

Salut,

le & ne sert-il pas à rendre a et B modifiable par la fonction? Ce que je ne souhaite pas.

Le & sert à indiquer que l'on passe l'argument par référence, de manière à en éviter la copie (qui peut s'avérer extrêmement coûteuse)...

Le fait est que, effectivement, lorsqu'un argument est passé par référence, les modifications que nous pourrions y apporter au sein de la fonction appelée seront répercutées dans l'objet originel de la fonction appelante.

C'est la raison pour laquelle il y a lieu de fournir une référence constante, de manière à ce que le compilateur t'insulte dés que tu essaye de la modifier.

Le passage d'une référence constante permet, en outre, de créer un temporaire anonyme qui n'existerait que pour la durée de l'appel de la fonction

Tout cela pour en arriver à un conseil qu'il s'agit de suivre de manière quasi impérative : veille à respecter la "const correctness", c'est à dire à déclarer constant tout ce qui n'a pas vocation à être modifié ou qui n'a pas vocation à modifier l'objet au départ duquel tu appelle une fonction donnée.

En effet, seules les fonctions membres déclarées constantes pourront être invoquées au départ des objets constants

[boutor]

Je progresse!

Merci koala01 pour cette très bonne explication et Joël pour le bout de code.

Dans le code j'en suis là :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
 
#include <iostream>
#include <vector>
 
template< typename T>
void show(std::vector< T > A)
{
    for(std::size_t i = 0; i < A.size(); ++i) {
        std::cout << A[i] << std::endl;
    }
}
 
 
template< typename T, class > std::vector<T>
operator*( T const& a, std::vector<T> const& b)
{
    std::vector<int> tmp(b);
    for(size_t i=0;i<tmp.size();++i) tmp[i] *= a;
    return tmp;
}
 
 
int main()
{
    std::vector<double> A(5), B;
    for(std::size_t i = 0; i < A.size(); ++i) {
        A[i] = (double)i;
    }
 
    std::cout << " A = " << std::endl;
    show(A);
    B = A;
    A = 5 * B;
 
    std::cout << " 5*A = " << std::endl;
    show(A);
    return 0;
}

Le compilateur ne semble toujours pas connaître l'opérateur:

error: no match for 'operator*' in '5 * B'|

[valAa]

Tu cherches à multiplier un int par un vecteur de double par (`5` sans autre précision est un int), alors que ton opérateur est prévu pour multiplier un T par un vector<T> (même type).

De plus Il y a une erreur dans ton opérateur, tu déclares tmp comme un vector<int> au lieu d'un vector<T> (ton compilateur te parlera de cette erreur dès que tu auras résolu la première).

[3DArchi]

Salut,
1/ Tu peux laisser les conversions jouer en séparant le type du scalaire de celui du vecteur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
template< typename vector_value_type, typename scalar_type>
std::vector<vector_value_type> operator*(std::vector<vector_value_type> const &B, scalar_type a)

2/ std::vector<int> tmp(b); fait une copie inutile de b dans tmp. Il existe un constructeur qui prend uniquement la taille et initialise à la valeur 0. Il devrait te suffire std::vector<int> tmp(b.size());.

3/ Comme il s'agit visiblement d'un apprentissage, regardes du côté des algorithmes (une piste, std::transform)

[valAa]

2/ std::vector<int> tmp(b); fait une copie inutile de b dans tmp. Il existe un constructeur qui prend uniquement la taille et initialise à la valeur 0. Il devrait te suffire std::vector<int> tmp(b.size());.

Je dirais
std::vector<vector_value_type> tmp(b.size()); vu que c'est le type de retour attendu.

[boutor]

Ca y est, je tiens le *=.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
template <class T, class Alloc, typename T2>
std::vector<T,Alloc>& operator*=(std::vector<T,Alloc> & this_, T2 a) {
     for( std::size_t i = 0; i < this_.size(); ++i) this_[i]*= (T)a; 
     return this_;
}

J'avoue ne pas bien comprendre la syntaxe, concernant le Alloc.

le * me résiste encore.

J'en suis là:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
template <class Ty, class Alloc, class T>
std::vector<Ty,Alloc> operator*(std::vector<Ty,Alloc> & A, T& a)
{
     std::vector<Ty,Alloc> tmp(A);
     A *= a; // C++11
     return tmp;
}

[3DArchi]

Salut,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
std::vector<Ty,Alloc> tmp(A);
A *= a;

Petite étourderie. Tu copie A dans tmp mais c'est dans A que tu fais l'opération. tmp *=a;.D'ailleurs tu n'aurais as du modifier le passage par paramètre constant. Quelqu'en soit l'implémentation, la signature de ton opérateur devrait rester avc des passages de paramètres par références constantes ou par valeur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
template <class Ty, class T>
std::vector<Ty> operator*(std::vector<Ty> const & A, T& a)
{

this_[i]*= (T)a; Cette conversion cachée me gêne. S'il doit y avoir une conversion, que celle-ci se fasse toute seule car si elle est risquée ou problématique, le compilateur va générer un avertissement ou une erreur. Ces informations peuvent être masquées si tu force la conversion : this_[i]*=a;

[Luc Hermitte]

Pour info: http://forum.ubuntu-fr.org/viewtopic.php?id=599931
Je continuerai éventuellement ici du coup.

[3DArchi]

Je comprend mieux d'où vient le commentaire C++11 et à quoi il fait référence

[boutor]

Pour info: http://forum.ubuntu-fr.org/viewtopic.php?id=599931
Je continuerai éventuellement ici du coup.

Super, tout le monde se rejoint.
Je continue sur le problème, la semaine prochaine.

Je vous tiens au courant de mes avancées.

[boutor]

J'en suis là et ça marche:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
template <class Ty, class Alloc, typename T>
std::vector<Ty,Alloc>& operator*=(std::vector<Ty,Alloc> & this_, T v_)
{
     for( std::size_t i = 0; i < this_.size(); ++i) this_[i]*= (Ty)v_; // C++11
     return this_;
}
 
template <class Ty, class Alloc, class T>
std::vector<Ty,Alloc> operator*(std::vector<Ty,Alloc> const & A, T const & a)
{
     std::vector<Ty,Alloc> tmp(A);
     tmp *= a;
     return tmp;
}

Merci à tous. Je vais continuer avec les autres opérateurs ( comme << pour l'affichage) et le chargement.

[3DArchi]

Salut,
Des petites remarques:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
template <class Ty, class Alloc, class T>
std::vector<Ty,Alloc> operator*(std::vector<Ty,Alloc> const & A, T const & a)
{
     std::vector<Ty,Alloc> tmp(A);
     tmp *= a;
     return tmp;
}

Tu passes l'argument par référence constante (ce que l'on a toujours appris), puis tu en fais une copie. Pourquoi ne pas faire la copie lors de l'appel en passant l'argument par copie ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
template <class Ty, class Alloc, class T>
std::vector<Ty,Alloc> operator*(std::vector<Ty,Alloc> A, T const & a)
{
     A *= a;
     return A;
}

C'est une petite astuce qui peut se révéler payante dans certains cas (NRVO, cf F.A.Q. pour explications)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
template <class Ty, class Alloc, typename T>
std::vector<Ty,Alloc>& operator*=(std::vector<Ty,Alloc> & this_, T v_)
{
     for( std::size_t i = 0; i < this_.size(); ++i) this_[i]*= (Ty)v_; // C++11
     return this_;
}

Pourquoi ne pas en profiter pour utiliser les algorithmes ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
template <class Ty, class Alloc, typename T>
std::vector<Ty,Alloc>& operator*=(std::vector<Ty,Alloc> & this_, T v_)
{
     std::transform(this_.begin(),this_.end(),this_.begin(),std::bind2nd(std::multiplies,v_));
     return this_;
}

Ceci dit, ta ligne de code this_[i]*= (T)a; reste problématique en cachant une conversion. Laisse le compilateur se plaindre si la conversion est hasardeuse : this_[i]*= a;

[oodini]

Pourquoi ne pas en profiter pour utiliser les algorithmes ?

Y a-t-il un avantage, en termes de performances ? Si oui, cela demande des éclaircissement.

Car en l'occurrence, l'instruction est plus longue et moins lisible pour un codeur débutant qui mettrait le nez dans le code.

[Luc Hermitte]

Pour la copy-elision, je ne pense pas que l'on y gagne grand chose ici, vu que c'est un code de 3 lignes qui est inliné. À tester.

Pour le transform, on n'y gagne pas en lisibilité je trouve.
BTW, OP, le code initial que je t'avais donné était limité au C++11 à cause du for-range. Là, cela ne l'est plus, le commentaire est donc hors propos.

+1 pour les conversions sinon. Et j'aurai tendance à dire qu'il ne sert à rien de la faire descendre au niveau de la boucle. La laisser au niveau de la signature me parait plus sensé. Au moins, l'utilisateur est prévenu dès l'appel s'il doit y avoir un cast qui restreint les types. (quoique avec la résolution automatique, on risque de devoir caster dans tous les cas ...)

[boutor]

Tu passes l'argument par référence constante (ce que l'on a toujours appris), puis tu en fais une copie. Pourquoi ne pas faire la copie lors de l'appel en passant l'argument par copie ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
template <class Ty, class Alloc, class T>
std::vector<Ty,Alloc> operator*(std::vector<Ty,Alloc> A, T const & a)
{
     A *= a;
     return A;
}

C'est une petite astuce qui peut se révéler payante dans certains cas (NRVO, cf F.A.Q. pour explications)

J'y avais pensé (en oubliant de virer le const ). Pour moi les deux solutions me semblent strictement identiques, si ce n'est une ligne de moins.

Désolé pour le cast, j'ai encore oublié de le virer!

[Emmanuel Deloget]

J'y avais pensé (en oubliant de virer le const ). Pour moi les deux solutions me semblent strictement identiques, si ce n'est une ligne de moins.

Désolé pour le cast, j'ai encore oublié de le virer!

Pour le compilateur, ça ne l'est pas du tout : certaines optimisations peuvent être réalisées de manière assez agressives par le compilateur dans ce cas précis.

Lis l'entrée de la FAQ pointée par 3DArchi pour comprendre.