Discussion :

[alexIsBack]

Bonjour à tous,

J'ai développé un code de traitement d'image qui ne travaille qu'avec des données "double", or, j'ai maintenant besoin de voir comment la baisse de précision influe sur mes calculs.

L'idée est de remplacer le type de données "double" par des objets de type template sur lesquels je peux effectuer les même opérations que je le fais normalement avec mes double.
par exemple:

Code :

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

1
2
3
4
5
6
7
	TemplateData <double> a;
	TemplateData <double> b;
	a=2;
	b=3;
	TemplateData <double>c;
	c=a+b;
	cout<<c<<endl;

Je travaille déjà avec les tempate donc, je connais en gros comment ca marche, mais pour ce que je veux faire là, je manque de connaissances.

En tout cas, il serait pour moi préférable de faire une classe template qui porte une valeur et des surcharges d'opérateurs pour toute les opérations communes: +, -, *, /, sqrt etc, avec des particularités pour les opérations sur les entiers (décalages etc)

voici un proto de ce que je voudrais faire, malheureusement, je n'ai pas suffisamment de connaissance pour la créer de façon fiable, bref, j'ai des erreurs ds tous les sens, pouvez vous m'aider?/ me corriger?

[/CODE]
en me basant sur une classe de ce genre 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
 
#ifndef TEMPLATEDATA_H_
#define TEMPLATEDATA_H_
 
using namespace std;
 
template <class Type>
class TemplateData
{
	Type _value;
	unsigned int _precision; // bit position of the decimal (used for integer operations)
public:
	// constructor/destructor
	TemplateData();
	TemplateData(Type &value):_value(value){};
	// destructor
	virtual ~TemplateData();
	// operators
	inline Type &operator=(const Type&);
	inline Type &operator+(Type addedValue){return _value+addedValue;};
	inline Type &operator-(Type retrievedValue){return _value-retrievedValue;};
	inline Type &operator*(Type factor){return _value*factor;};
	inline Type &operator/(Type divider){return _value/divider;};
 
 
protected:
		void _setIntegerPrecision(const unsigned int decimalOffset){_precision=decimalOffset;};
 
};
 
#endif /*TEMPLATEDATA_H_*/

avec cela, j'ai des erreurs dues à mon ignorance des templates
ca me dit "no match for oerator + in a+b", bon, là, je ne sais pas gérer la surcharge apparemment.

et puis "no match for operator<< in std::cout<<c" pour lui, c'est sur, je n'ai pas surchargé l'opérateur...et pour cause, comment fait-on?

Merci pour votre aide

[Médinoc]

Il faut surcharger l'opérateur extérieurement à la classe.
C'est d'ailleurs aussi recommandé pour tous les autres opérateurs que tu surcharges...

Pour l'opérateur <<, on définit généralement hors de la classe une fonction qui a ce prototype :

Code :

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

1
2
3
4
5
6
7
ostream & operator<< (ostream & os, MaClasse const &obj)
{
   //affichage
   //...
 
   return os;
}

Ici, c'est un peu plus compliqué comme tu as un template, mais c'est l'idée générale...

PS: Y'a des const qui se perdent dans pas mal de tes paramètres passés par référence...