Discussion :

[Laurent Gomila]

Soit en fonction non-membre comme dans mon précédent post, soit en fonction membre comme ceci

Code :

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

1
2
3
4
5
6
template <class T> Vector
{
   // ...
 
   template <class U> Vector<T> operator *(const U& u);
};

Et bien sûr tu n'as plus besoin de SVector et de toutes ces "bidouilles".

A noter que tu peux avoir des difficultés avec ce genre de code, si tu compiles avec VC6. Dans ce cas, prendre la version non-membre peut régler un éventuel problème de compilation.

[BlackGoddess]

je verrais ca comme ca ...
(d'apres ce que j'ai compris que tu voulais)

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
 
#include <vector>
#include <algorithm>
 
template<typename T>
class Vector : public std::vector<T> // pour l'exemple, apres faudrait encapsuler proprement
{
	template <typename Type>
	class MultValue
	{
	private:
		Type Factor;
	public:
		MultValue ( const Type& _Val )
			: Factor ( _Val )
		{
		}
 
		int operator ( ) ( Type& elem ) const 
		{
			return elem * Factor;
		}
	};
 
public:
 
	template<typename Param>
	Vector<T> operator * (const Param & p)
	{
		Vector<T> r;
		r.reserve(size());
		std::transform(begin(), end(), r.begin(), MultValue<Param>(p));
		return r;
	}
};
 
int main()
{
	Vector<int> v, w;
	w = v*3;
 
}

[Math75]

en effet j ai une version VC6
ce qui explique que ca ne compile pas
c est pourquoi j ai pense a ce strategeme

Soit en fonction non-membre comme dans mon précédent post, soit en fonction membre comme ceci

Code :

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

1
2
3
4
5
6
template <class T> Vector
{
   // ...
 
   template <class U> Vector<T> operator *(const U& u);
};

Et bien sûr tu n'as plus besoin de SVector et de toutes ces "bidouilles".

A noter que tu peux avoir des difficultés avec ce genre de code, si tu compiles avec VC6. Dans ce cas, prendre la version non-membre peut régler un éventuel problème de compilation.

[Laurent Gomila]

[pinaillage]

Je pense que MultValue::operator () devrait renvoyer un T plutôt qu'un int, non ?

Sinon pour la multiplication à moindre frais (en terme de lignes de code), je pense qu'on peut s'en tirer avec un std::multiplies et un std::bind2nd, par exemple.

EDIT : Ton opérateur va crasher je pense, il faut soit utiliser resize au lieu de reserve, soit utiliser un back_inserter.

[/pinaillage]

[Laurent Gomila]

En théorie VC6 n'aime pas les fonctions membres templates de classes templates. En pratique, si tu ne sépares pas la définition de la déclaration, ça devrait compiler. Sinon, comme je l'ai dit le fait de faire de tes opérateurs des fonctions non-membres devrait passer sans problème.

[Laurent Gomila]

...Et à noter aussi que pour avoir des vecteurs "mathématiques" il existe la classe std::valarray, qui permet entre autres d'effectuer ce genre d'opération.

Par contre je n'arrive pas à la trouver dans mes docs de référence, est-elle bien standard ?

[Luc Hermitte]

std::valarray est standard. Par contre son implémentation efficace est récente. (oubliez VC6)
Je préfère lorgner du côté de Blitz++ et à termes de boost::ublas.

Les opérations sur des vecteurs se portent beaucoup mieux quand elles sont non membres. Cela permet d'avoir des opérations véritablement commutatives et qui supportent les cast implicites -- en rendant la fonction membre template, ce n'est plus forcément utile.

(Sinon un code compliqué que je n'ai pas cherché à approfondir.)

[BlackGoddess]

Loulou24
=>
en effet on peut remplacer class MultValue par std::multiplies, je ne conaissais pas ...

pour l'erreur du int, c'est parce que j'ai recopié betement mon exemple des MSDN qui faisait exactement cela, mais qui contenait aussi cette erreur.