Discussion :

[ikeas]

bonjour,

j'ai la structure suivante

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
class AcquisitionBase  {
private:
double value;
public:
virtual string toString() = 0;
virtual double getInvariantValue() = 0;
}
 
template<typename T>
class Acquisition: public AcquisitionBase{
private:
T v;
public:
Acquisition(T vlaue) : v(value) {
}
virtual string toString() {
    return "information";
}
virtual double getInvariantValue() {
    return (double)v;
}
}

avec

Code :

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

1
2
3
4
 
typedef float ANALOG;  		
typedef unsigned short DIGITAL; 
typedef bool LOGIC;

et je veux implémenter l’opérateur + (par exemple mais en fait je vais les faires tous) pour faire des calcul avec
Acquisition<ANALOG> + Acquisition<DIGITAL> etc ....

donc dans le template j'ai ajouté

Code :

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

1
2
3
4
5
 
virtual Acquisition<T> operator+(AcquisitionBase &ob) {
	return Acquisition<T>(
		this->getInvariantValue() + ob.getInvariantValue());
}

mais j'ai l'erreur suivante quand je rajoute l’opérateur pour les littéraux (dont j'ai aussi besoin évidement pour faire Acquisition<ANALOG> + 21)

Code :

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

1
2
3
4
template<typename T>
Acquisition<T> operator+(Acquisition<T> &ref, int ob) {
	return Acquisition<T>(ref.getInvariantValue() + ob);
}

ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second:

étonnamment quand je fais

Code :

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

1
2
3
4
template<typename T>
Acquisition<T> operator+(int ob) {
	return Acquisition<T>(this->getInvariantValue() + ob);
}

je n'ai pas d'erreur, mais si j'ai mis un opérateur externe c'est pour résoudre les deux cas

• Acquisition<ANALOG> +21
• 21 + Acquisition<ANALOG>

avec

Code :

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

1
2
3
4
template<typename T>
Acquisition<T> operator+(int ob, Acquisition<T> &ref) {
	return ref + ob;
}

bref avez vous une solution pour

• soit éviter d'afficher cette erreur (je suis sur linux avec g++ 4.4.6)
• soit changer la structure

merci et bonne soirée de Noël a vous tous....

NOTA : sur visual studio 2013 j'ai pas d'erreurs

[ternel]

Quelque chose me choque dès le départ.
Dans AcquisitionBase, il y a un double (value) privé, sans accesseur aucun, ni constructeur.
C'est une variable perdue.

Si je résume, tu veux que tes classes Acquisition<T> aie toute une toString() et une getInvariantValue().

Et tu veux que pour tout T1 et T2, operator +(Acquisition<T1>, Acquisition<T2>) retourne la somme des getInvariantValue()?
De plus, tu veux aussi pouvoir utiliser un nombre dans la somme?

L'idée de l'opérateur implémenté en fonction libre est qu'il peut être appelé via une conversion du premier argument, alors que ce n'est pas le cas de la fonction membre.
Pour cela il faut une opération de conversion, c'est à dire un constructeur implicite.


Sauf qu'ici, tu auras plusieurs conversions possible, et que 12 n'est pas une acquisition, mais juste 12.

Et si tu prenais le problème à contrepied?
Les nombres ont tous les opérateurs mathématiques prédéfinis, il suffirait d'avoir une opération de conversion vers les nombres.

Que penses-tu de ceci?

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
47
48
49
50
51
#include <iostream>
 
namespace data{
 
typedef float ANALOG;  		
typedef unsigned short DIGITAL; 
typedef bool LOGIC;
 
class AcquisitionBase  {
protected:
	~AcquisitionBase(){}
public:
	virtual std::string toString() const = 0;
	virtual double getInvariantValue() const = 0;
 
};
 
template<typename T>
class Acquisition: public AcquisitionBase{
private:
	T v;
public:
	explicit Acquisition(T value) : v(value) {}
 
	virtual std::string toString() const {
		return "information";
	}
 
	virtual double getInvariantValue() const {
		return (double)v;
	}
 
	//conversion template
	operator T() const {return v;}
};
 
};//data::
 
using namespace data;
 
int main() {
	Acquisition<DIGITAL> digit(7);
	Acquisition<ANALOG> analog(12);
 
	std::cout << "digit + :" << (digit + 4.1) << std::endl;
	std::cout << "+ digit :" << (4.1 + digit) << std::endl;
	std::cout << "analog +:" << (analog + 3) << std::endl;
	std::cout << "+ analog:" << (3 + analog) << std::endl;
	std::cout << "somme   :" << (digit + analog) << std::endl;
	std::cout << "produit :" << (digit * analog) << std::endl;
}

[ikeas]

Quelque chose me choque dès le départ.
Dans AcquisitionBase, il y a un double (value) privé, sans accesseur aucun, ni constructeur.
C'est une variable perdue.

oui je sais elle n'a aucune importance c’était résiduel lol

pour le reste ton idée est séduisante mais pour l'exemple j'ai botté en touche que la classe AcquisitionBase possède aussi une validité ca donne ca en réel et que cette validité doit être préservée pour les calculs ....

Code :

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

1
2
3
4
5
6
7
8
 
class AcquisitionBase: public IObjectType<AcquisitionBase>,
		public IToString,
		public IType,
		public IValidity { ... }
 
template<typename T>
class Acquisition: public AcquisitionBase, public Value<T> { ... }

si tu veux ce que je comprend pas c'est pourquoi avec g++ ca me colle une tartine de warning et sur visual studio tres peut
en fait visual studio me dit juste que ANA en double je risque de perdre des choses ....

[r0d]

Bonjour,

Concernant les warnings, j'imagine que le niveau de warning par défaut n'est pas le même dans vs et dans gcc.
Dans vs, tu peux le régler dans les propriétés du projet -> C/C++ -> general -> warning level

[ikeas]

dans eclipse je trouve un trucs dans code analysis mais c pas vraiment clair

[oodini]

As-tu lu cet article ?

Apparemment, tu ne nous donnes pas la totalité du message d'erreur.

[ikeas]

voici les messages que j'ai

candidate 1: cy::ln2_type::Acquisition<T> cy::ln2_type::Acquisition<T>::operator+(cy::ln2_type::AcquisitionBase&) [with T = float]
candidate 2: cy::ln2_type::Acquisition<T> cy::ln2_type::operator+(double, cy::ln2_type::Acquisition<T>&) [with T = float]

j'ai tenté de mettre le constructeur en explicit mais sans resultat

[oodini]

Apparemment, il hésite entre l"opérateur unaire et binaire.
Il faut choisir, camarade. Avec une forte préférence pour l'opérateur binaire.