Class dans une Class

Version imprimable

Voir 40 message(s) de cette discussion en une page

06/08/2004, 16h48
Laurent Gomila
Soit en fonction non-membre comme dans mon précédent post, soit en fonction membre comme ceci
Code:

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.

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

Code:

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;
 
}

06/08/2004, 17h05
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
Citation:
Envoyé par Loulou24

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

Code:

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.
06/08/2004, 17h06
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]
06/08/2004, 17h09
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.
06/08/2004, 17h14
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 ?
06/08/2004, 17h24
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.)
06/08/2004, 17h38
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.

Voir 40 message(s) de cette discussion en une page