Discussion :

[Fry]

Bonjour

Est ce qu'il est possible d'utiliser les templates dans l'operateur pour assurer que l'objet passe est bien construit avec le type voulu et pour permettre de surcharge la fonction?

Par example:

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
 
class duree // classe englobant l heure les minute et les seconde
{
public:
	duree(){ val = 2; }
	int val;
};
 
class date // classe englobant les anne, les mois, les jour, les heure, les minutes, les seconeds 
{
public:
	date(){ val = 3; }
	int val;
};
 
template <class T>
class _clock
{
public:
	T temps;
	void print()
	{
		std::cout << temps.val << std::endl;
	}
 
	template <class T>	friend _clock  operator + (const _clock<date> &c1, const _clock<duree> &c2)
	{
		_clock ret;
		return ret;
	}
	friend _clock<date> operator - (const _clock<date> &c1, const _clock<duree> &c2)
	{
		_clock ret;
		return ret;
	}
};

ne compile pas...
Le but est de pouvoir faire comme ca:

Code :

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

1
2
3
4
5
6
7
 
_clock<date> d1;
_clock<date> d2;
_clock<duree> d3;
 
std::cout << "Temps entre les 2 dates: " << d1 - d2 << std::endl;
std::cout << "Temp  enleve a d1: " << d1 - d3 << std::endl;

Je ne sais pas si c'est une bonne idee de faire une difference entre la date et la duree

[Matthieu Brucher]

C'est quoi l'erreur ?

[Fry]

L'erreur se situe au niveau de la syntaxe avec les template je sais pas comment ecrire la surcharge des operateur pour que ca marche.

j ai modifier la syntaxe comme ca:

Code :

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

1
2
3
4
5
6
 
template <date>	friend _clock  operator + (const _clock<date> &c1, const _clock<duree> &c2)
{
	_clock ret;
	return ret;
}

mais j obtien mnt cette erreur sur la ligne de declaration de la fct:

error C2993: 'date' : illegal type for non-type template parameter '__formal'

[Matthieu Brucher]

C'est quoi le friend qui se balade ?

[Twindruff]

Si tu déclares ton operateur avec 2 arguments il doit être à l'extérieur de la classe. Si tu veux le déclarer à l'intérieur il n'y a qu'un argument et
a+b <=> a.operator+(b)

[Fry]

Le friend sert justement a declarer l'operateur a l interieur de la classe effectivement il vaut mieu ecrire declarer l'operateur comme ca

Code :

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

1
2
3
4
5
 
template <date> _clock  operator + ( const _clock<duree> &c2)
{
 
}

mais j ai tjr la meme erreur: error C2993: 'date' : illegal type for non-type template parameter '__formal'

[Matthieu Brucher]

friend, c'est pour déclarer uen fonction amie à l'extérieure de la classe.
Là, une erreur est au moins évidente : c'est quoi date ?

[xxiemeciel]

salut,

pourquoi declare tu l'operateur + template avec T et ensuite tu utilises date, je pense ton template est fait bizarrement, tu as aussi oublier le template a la fin de _clock dans l'operateur +

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
 
template <class T>
class _clock
{
public:
	T temps;
	void print()
	{
		std::cout << temps.val << std::endl;
	}
 
	friend  _clock<T>  operator + (const _clock<T> &c1, const _clock<duree> &c2)
	{
		_clock ret;
		return ret;
	}
	friend _clock<T> operator - (const _clock<T> &c1, const _clock<duree> &c2)
	{
		_clock ret;
		return ret;
	}
};

ensuite tu peux toujours utiliser un dynamic_cast pour verifier que ton template est date ou duree. Par contre si tu as seulement deux possibilitees de template je pense que je l'aurais fais avec du polymorphisme plutot que des templates. parceque dans ton cas que va-t-il se passer si tu fais :

Code :

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

1
2
 
_clock<std::string> MaClockQuiVaPlanter ;

[Fry]

ben pk le friend marche aussi pour les fonction externe declarer a l interieur de la classe ?
et date c'est la classe date qui est declarer au dessus

mais je ne sais tjr pas si les templates sont adapte a l'utilisation que j essai d en faire la...

le but etant d'avoir une classe qui en fonction de son type de templates est traite diferrement par les operateur de la classe, je cherche donc la bonne implementation pour faire ca.

Effectivement je peu obtenir le type avec un dynamic_cast et effectuer alors le traitement adapte

[Matthieu Brucher]

ben pk le friend marche aussi pour les fonction externe declarer a l interieur de la classe ?

On déclare dans le corps de la classe un prototype de la fonction auquel on ajoute le mot-clé friend, c'est tout.

et date c'est la classe date qui est declarer au dessus

Dans ce cas pourquoi est-il entre <> ?

mais je ne sais tjr pas si les templates sont adapte a l'utilisation que j essai d en faire la...

le but etant d'avoir une classe qui en fonction de son type de templates est traite diferrement par les operateur de la classe, je cherche donc la bonne implementation pour faire ca.

Effectivement je peu obtenir le type avec un dynamic_cast et effectuer alors le traitement adapte

Normalement, les templates marchent très bien, mais je me demande si tu les maîtrises bien...

[xxiemeciel]

ben pk le friend marche aussi pour les fonction externe declarer a l interieur de la classe ?
et date c'est la classe date qui est declarer au dessus

mais je ne sais tjr pas si les templates sont adapte a l'utilisation que j essai d en faire la...

le but etant d'avoir une classe qui en fonction de son type de templates est traite diferrement par les operateur de la classe, je cherche donc la bonne implementation pour faire ca.

Effectivement je peu obtenir le type avec un dynamic_cast et effectuer alors le traitement adapte

a mon avis tu ne maitrises pas bien les templates, normalement on utilise les template pour faire des classes generiques capablent de manipuler plusieurs types facilement. Dans ton cas tu proposes un template generique mais tu le specialises en date ou duree, tu perds donc l'interet des templates.

pour cela je pense les templates ne sont pas la bonne solution a ton probleme. utilise du polymoprhisme plutot. une Interface Temps et deux classes Date et Duree qui vont heriter de ton Interface Temps, quelques fonctions et un peu de virtualite et le tour est joue.

[Fry]

ben j ai mis date entre <> pour surcharger l operateur en fonction du type car je voulai eviter d'utiliser l heritage et tout mettre dans une classe mais je vai faire comme xxiemeciel a dit.

Effectivement je ne maitrise pas les templates mais j essai de les utiliser de temp en temp

[Matthieu Brucher]

mettre template <date> n'a aucun sens car date est fixé pour la fonction, ce n'est pas un arguùment template.

[Fry]

ca revient un peu a mettre directement date car le compilateur remplace " template<date> " par " date " ?

C'est un peu ce que je voulai savoir si mon code avait du sens car j etait pas sur de ma modelisation et j'ai voulu essaye d'utiliser les template a mauvais escient

[Matthieu Brucher]

Non, le compilateur ne comprend pas template <date>. Il comprendrait qqch du style template<class date> en râlant parce que date est un type déjà défini, mais autrement, ça plante. Regarde la FAQ sur les templates

[Luc Hermitte]

Je ne sais pas si c'est une bonne idee de faire une difference entre la date et la duree

Par expérience, l'autre approche est source de mauvaises surprises. Cela permet aux mainteneurs d'avoir autre chose à se demander si il faut revérifier les calculs simples faits sur les dates.

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
// .h
struct TimeRepresentation {
    timeval tv; // deux time_t
};
 
 
struct Date {
    friend struct Duree;
    ....
    Date & operator+=(Duree const& duree);
    Date & operator-=(Duree const& duree);
private:
    TimeRepresentation tr_;
};
 
struct Duree {
    friend struct Date;
    ....
    Duree & operator+=(Duree const& duree);
    Duree & operator-=(Duree const& duree);
    Duree & operator+=(Date const& date);
    Duree & operator-=(Date const& date);
 
    Duree & operator*=(double);
private:
    TimeRepresentation const& getTR() const { return tr_; } // pour les amis
    TimeRepresentation tr_;
};
 
// pas amis, c'est inutile!
Date operator+(Date const& lhs, Duree const& rhs);
Date operator+(Duree const& lhs, Date const& rhs);
Duree operator+(Duree const& lhs, Duree const& rhs);
 
Duree operator-(Date const& lhs_, Date const& rhs_)
// op*(duree, double), (double, duree), ...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// .cpp
TimeRepresentation operator+(
    TimeRepresentation const& lhs, TimeRepresentation const& lhs)
{ ... }
// op-, op*
 
Date & Date::operator+=(Duree const& lhs) {
    tr_ += lhs.getTR();
    return *this;
}
...
Date operator+(Date const& lhs, Duree const& rhs)
{ return Date(lhs) += rhs; }
...

Quite à s'amuser avec l'héritage, privé sinon rien. Ici on ne se substitue pas, on se définit à l'aide de.

Il y a des trucs à taper, mais rien qui prenne plus d'une demi-journée à faire si on est obligé d'utiliser un truc défini à la mano. (il y a tout ce qui faut chez boost). Quand c'est un exercice que l'on fait pour la première fois, cela peut prendre un peu plus de temps.