Discussion :

[Pingouin22]

J'ai une classe triangle à faire, mais il me faut des idées sur ce que l'on pet faire sur un triangle et comment on peut le définir.

- Trois points déja
- Calcule de la surface
- surcharge de l'opérateur =

Mais pour l'opérateur == comment voir si deux triangles st identiques ?
A ouep info : les points sont définis dans R²

[aoyou]

J'espère qu'avant tout, tu disposes d'une classe Point.

Avant de surcharger l'opérateur =, je me serais déjà demandé si c'était nécessaire.
http://cpp.developpez.com/faq/cpp/?p...GE_affectation

Il faudra écrire explicitement un opérateur d'affectation dès lors qu'une simple affectation membre à membre des données de votre classe n'est plus suffisante, par exemple si elle gère une ressource (un pointeur brut, une connexion à une base de données, une texture en mémoire vidéo, ...).

Donc, question à te poser avant tout, comment va-tu stocker tes points ? Agrégation ou composition ? De là, en découlera la surcharge ou non de = (mais pas que ça...)

Tu peux dire que deux triangles sont identiques quand leurs points sont identiques deux à deux (ça t'oblige à plusieurs tests d'égalité au pire 6)

Tu pourrais rajouter :

• translation
• rotation

[Pingouin22]

Je stocke mes points par composition, j'ai une classe point et vecteur

[aoyou]

Donc, à priori, tu n'utiliseras pas de pointeur pour stocker tes points, donc aucun intérêt de surcharger l'opérateur =. Le compilateur le fera très bien à ta place.

Très bien la classe vecteur mais c'est pour quoi ? Faire des translations ?

[Pingouin22]

Je t'explique, j'ai un test samedi, et le prof ns a dit sa tombe sur triangle, vecteur et point sans ns donner de .h donc on doit réfléchir a tt ce qu'on peut faire sur un triangle, un vecteur et sur un point, donc point et ds R².
Un vecteur lui on peut le transposer, mais aussi le surcharger :

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
 
class Vecteur : public CObject {
DECLARE_SERIAL (Vecteur)
private :
	double m_dX;
	double m_dY;
public :
	Vecteur () {}
	Vecteur (double, double);
	Vecteur (Point, Point);
	Vecteur (Vecteur&);
 
	double ProjX () { return m_dX; }
	double ProjY () { return m_dY; }
 
	Vecteur operator = (Vecteur);		// Surcharge des operateurs
	Vecteur operator + (Vecteur);
	Vecteur operator +=(Vecteur);
	Vecteur operator - (Vecteur);
	Vecteur operator -=(Vecteur);
	double  operator * (Vecteur);		// Attention : produit scalaire !
	bool operator == (Vecteur);
	bool operator != (Vecteur);
	friend ostream& operator <<(ostream&, Vecteur);
 
	double Norme ();					// Declaration des services				
	bool Colineaire(Vecteur);
	bool DeMemeSens(Vecteur);
	bool Orthogonal(Vecteur);
};

[aoyou]

Ca manque de const et de référence toutes ces déclarations. A moins que vous ne l'ayez pas encore vu...

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
 
class Vecteur : public CObject {
  DECLARE_SERIAL (Vecteur)
 
private :
  double m_dX;
  double m_dY;
 
public :
 
  Vecteur () : m_dX (0) , m_dY (0) {} // au moins initialiser à 0 ?
  Vecteur (double, double);
  Vecteur (const Point &, const Point &);
  Vecteur (const Vecteur &);
 
  double ProjX () const { return m_dX; }
  double ProjY () const { return m_dY; }
 
  // Vecteur & operator = (const Vecteur &); // Inutile
  Vecteur   operator +  (const Vecteur &) const;
  Vecteur & operator += (const Vecteur &);
  Vecteur   operator -  (const Vecteur &) const;
  Vecteur & operator -= (const Vecteur &);
  double    operator *  (const Vecteur &) const;
  bool      operator == (const Vecteur &) const;
  bool      operator != (const Vecteur &) const;
 
  friend std::ostream & operator << (std::ostream &, const Vecteur &);
 
  double Norme () const;
  bool Colineaire(const Vecteur &) const;
  bool DeMemeSens(const Vecteur &) const;
  bool Orthogonal(const Vecteur &) const;
 
};

[JolyLoic]

Je suis toujours gêné par ce genre de question. L'interface d'une classe ne se conçoit pas sans un contexte d'utilisation. En informatique, l'essence précède l'existence. Une classe triangle pour un logiciel de type illustrator ressemblerait peu à un triangle d'un logiciel de géométrie variationelle, et n'aurait rien à voir avec un triangle d'un moteur 3D.

[Pingouin22]

Le but de cela est de faire un puzzle avec une méthode backtracking mais pour cela il faut peut être avoir les outils....

[nicroman]

Il manque (à mon avis) pas mal de fonctions dans ta classe Vecteur, et aussi beaucoup d'inline... :

Produit-vectoriel

Code :

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

1
2
3
 
inline double  operator ^(const Vector& v) const
{ return v.dy * dx - v.dx * dy; }

Produit par un scalaire:

Code :

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

1
2
3
4
5
6
7
8
9
 
inline Vector& operator*=(double f)
{ dx *= f; dy *= f; return *this; }
inline Vector operator*(double f) const
{ return Vector(dx * f ,  dy * f); }
inline Vector& operator/=(double f)
{ dx /= f; dy /= f; return *this; }
inline Vector operator/(double f) const
{ return Vector(dx / f ,  dy / f); }

Sur la normalisation:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
inline double SquaredLength() const
{ return (dx * dx + dy * dy); }
inline double RecipSquaredLength() const
{ return 1 / SquaredLength(); }
inline double Length() const
{ return sqrt(SquaredLength()); }
inline double RecipLength() const
{ return rsqrt(SquaredLength()); } // <= sur certaines machines rsqrt est intrasèque
inline Vector& Normalize()
{ return operator *= RecipLength(); }

Accès aux membres:

Code :

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

1
2
3
4
5
6
7
8
9
 
inline double DX(void) const
{ return dx; }
inline double& DX(void)
{ return dx; }
inline double DY(void) const
{ return dy; }
inline double& DY(void)
{ return dy; }

Quand à la construction, le constructeur "par défaut" devrait ne rien faire du tout, pour permettre de tracker (en debug) facilement les Vecteur non initialiser (et les différentier facilement des Vecteurs nulls)

Et puis pour finir, les tests.... A bien implémenter en utilisant une fonction à précision variable (les tests d'égalité entre deux flottants sont à éviter, y compris avec 0).

Code :

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

1
2
3
4
5
6
7
8
9
 
inline IsNull(void) const
{ return IsDoubleNull(dx) && IsDoubleNull(dy); }
inline operator bool (void) const
{ return !IsNull() }
inline operator==(const Vector& v) const
{ return IsDoubleNull(v.dx - dx) && IsDoubleNull(v.dy - dy); }
inline operator!=(const Vector& v) const
{ return !IsDoubleNull(v.dx - dx) || !IsDoubleNull(v.dy - dy); }

etc...

[Laurent Gomila]

Code :

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

inline double  operator ^(const Vector& v) const

Perso je n'utiliserais pas l'opérateur ^ pour ça, mais plutôt une fonction libre. L'opérateur ^ en C++ n'a ni la même signification, ni les mêmes règles de priorité que l'opérateur mathématique de produit vectoriel.
Sans parler du fait que le produit scalaire (qui va généralement de paire avec) n'a pas son opérateur en C++.

Code :

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

1
2
inline double RecipSquaredLength() const
{ return 1 / SquaredLength(); }

N'oublie pas de vérifier le cas où le vecteur est nul

[nicroman]

N'oublie pas de vérifier le cas où le vecteur est nul

Bah... ca fera une jolie exception sans rien toucher !

[Mat007]

Salut,

Quand à la construction, le constructeur "par défaut" devrait ne rien faire du tout, pour permettre de tracker (en debug) facilement les Vecteur non initialiser (et les différentier facilement des Vecteurs nulls)

Toi tu tombes bien, tu vas pouvoir m'expliquer ça un peu plus précisément.
Il y a cette fonctionnalité dans ogre par exemple et je trouve ça ... bizarre (ou alors je ne l'utilise pas correctement)...
D'abord je ne compile quasiment jamais en debug, mais bon mettons...
Ensuite oui ça fait un vecteur initialisé avec n'importe quoi, et donc en quoi ça m'aide ?
En quoi si je veux un vecteur nul c'est mieux de devoir l'initialiser manuellement avec 0 (ou par une constante) ?
Je croyais que c'était l'intérêt du constructeur de justement permettre de réaliser une initialisation correcte en toute circonstance ?

Comment est-on supposé utiliser cette fonctionnalité ?

MAT.

[Mat007]

Bah... ca fera une jolie exception sans rien toucher !

Hmm pour moi une division par 0 ne lève pas d'exception, ça donne std::numeric_limits< double >::infinity().

Tiens sinon que signifie recip dans RecipSquaredLength() ?
Ca en vraiment un intérêt d'encombrer la classe avec une méthode qui fait juste 1 / résultat d'une autre méthode ?

MAT.

[smashy]

Il manque (à mon avis) pas mal de fonctions dans ta classe Vecteur, et aussi beaucoup d'inline... .

Inline , ca ne sert a rien, les compilo actuels savent mieux que nous comment optimiser le code, et le font ou pas independamment du mot cle inline (idem pour register)