correction d'une classe point.

**deubelte** · 19/05/2007, 13h35

Voici une classe que j'ai faite: il s'agit d'une classe "Point" dans laquelle on rentre les coordonnées d'un point P et il ressort les coordoonnées après la rotation, l'homotéthie ou un déplacement.

dites moi ce que vous en pensez, et comment l'améliorer. merci
merci

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
#include<iostream>
#include<stdio.h>
#include<math.h>
 using namespace std;
const float Pi=3.1415;
 
 class Point{
 
  float x,y;
public:
	Point(float x ,float y);
	 void affiche();
	 void deplace(float , float );
	 float  abscisse();
	 float ordonnée();
	 void homotethie(float);
	 void rotation(float);
	 float rho(float,float);
	 float theta(float,float);
 
};
 
Point::Point(float ab,float ord){
x=ab;
y=ord;
}
void Point::rotation(float angle){
char *c[2];
x=cos(angle)*x-sin(angle)*y;
y=sin(angle)*x+cos(angle)*x;
 
  float ang=theta(x,y);
  float ray=rho(x,y);
  printf("lescoordonnees polaires de p apres la rotation sont ");printf("%f et %f\n",ang,ray);
}
void Point::homotethie(float rap){
x=x*rap;
y=y*rap;
}
 
float   Point::theta(float x,float y){
 	if (x!=0) { return atan(y/x);}
 }
 
 float Point::rho(float x,float y){
 	return sqrt (x*x+y*y);
 }
 
 
float Point::ordonnée(){
return y;
}
float Point::abscisse(){
return x;
}
void Point::deplace(float dx,float dy){
x=x+dy;
y=y+dx;
}
void main(){
Point p(3,3);
cout<<"les coordonnees initiales sont "<<p.abscisse()<<" et "<<p.ordonnée()<<endl;
p.deplace(4,100);
cout<<"les coordonnees de p apres le deplacement sont "<<p.abscisse()<<" et "<<p.ordonnée()<<endl; 
p.homotethie(4);
cout<<"les coordonnees de p apres l'homothetie sont "<<p.abscisse()<<" et "<<p.ordonnée()<<endl; 
p.rotation(Pi/2);
 
}

**gér@rd lambert** · 19/05/2007, 14h33

Salut !

Il existe une constante pour PI dans math.h au lieu de déclarer une constante approximative.
Elle s'appelle M_PI je crois

**Laurent Gomila** · 19/05/2007, 15h07

Salut

Il existe une constante pour PI dans math.h au lieu de déclarer une constante approximative.
Elle s'appelle M_PI je crois

Sauf qu'elle n'est pas toujours définie, ce qui est un peu embêtant.

Sinon voilà quelques remarques :

1/ Mixer iostream et stdio.h n'est pas ce que l'on fait de mieux. Pourquoi utiliser printf en C++ ?

2/ Ta classe ne possède pas de constructeur par défaut, ce qui me semble indispensable pour une telle classe

3/ Les fonctions ne modifiant pas les données membres telles que affiche(), abscisse(), ordonnee(), ... devraient être const

4/ J'ai vu un char *c[2] dans la fonction rotation qui ne servait à rien

5/ atan2(x, y) remplacera avantageusement atan(x / y)

6/ J'ai pas compris le rôle de rho et theta, qui n'utilisent pas les x et y du point

7/ La fonction affiche devrait être un operateur <<. Tu devrais également définir l'opérateur >> pour la saisie

8/ Il n'y a aucun moyen de modifier arbitrairement les coordonnées du point après sa construction ?

**deubelte** · 19/05/2007, 15h21

un grand merci a Laurent pour toutes ces informations.

2/ Ta classe ne possède pas de constructeur par défaut, ce qui me semble indispensable pour une telle classe

>>Pour moi, voici le constructeur par défaut. Sinon, je ne sais pas ce que c'est que le constructeur par défaut.

Code :

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

1
2
3
4
5
 
Point::Point(float ab,float ord){
x=ab;
y=ord;
}

4/ J'ai vu un char *c[2] dans la fonction rotation qui ne servait à rien
>>oui, a virer.

5/ atan2(x, y) remplacera avantageusement atan(x / y)
>>quelle est la différence?

6/ J'ai pas compris le rôle de rho et theta, qui n'utilisent pas les x et y du point
>>>rho et theta renvoient les coordonnées polaires.
>>d'après moi, rho et theta utilisent bien les coordonnées du point:

Code :

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

1
2
3
4
 
 float Point::rho(float x,float y){
 	return sqrt (x*x+y*y);
 }

3/ Les fonctions ne modifiant pas les données membres telles que affiche(), abscisse(), ordonnee(), ... devraient être const
>>ok

8/ Il n'y a aucun moyen de modifier arbitrairement les coordonnées du point après sa construction ?
>>comment pourrait-on faire?

7/ La fonction affiche devrait être un operateur <<. Tu devrais également définir l'opérateur >> pour la saisie
>>la fonction affiche est un reste d'une premiere version de cette classe.
elle sert à rien ici.

**Laurent Gomila** · 19/05/2007, 15h29

>>Pour moi, voici le constructeur par défaut. Sinon, je ne sais pas ce que c'est que le constructeur par défaut.

Un constructeur par défaut est celui qui ne prend pas de paramètre. Actuellement tu ne peux pas déclarer un point comme ceci :

Code :

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

Point p;

>>quelle est la différence?

Il existe deux angles distincts pour une arctangente donnée, donc tu as une chance sur deux d'obtenir le bon angle avec atan. Par contre en donnant le sinus et le cosinus séparément via atan2, là tu as le bon angle de manière unique. D'autant plus que ça gère pour toi le cas de la division par zéro.

>>>rho et theta renvoient les coordonnées polaires.
>>d'après moi, rho et theta utilisent bien les coordonnées du point:

Ben non, ils utilisent les x et y passés en paramètre (qui servent à quoi alors ?).

>>comment pourrait-on faire?

Des fonctions genre setAbscisse, setOrdonnee. Ou alors placer x et y en accès publique. Cela dépend de ce que tu veux faire faire à ta classe Point.

**deubelte** · 19/05/2007, 15h39

Un constructeur par défaut est celui qui ne prend pas de paramètre. Actuellement tu ne peux pas déclarer un point comme ceci :
Point p;

Il suffirait de mettre Point p; quelque part dans ma classe?

Ben non, ils utilisent les x et y passés en paramètre (qui servent à quoi alors ?).

Je suis d'accord. Il servent juste a calculer les coordonnées polaires. Et la fonction renvoie ces deux coordonnées polaires.

**Laurent Gomila** · 19/05/2007, 16h09

Il suffirait de mettre Point p; quelque part dans ma classe?

Envoyé par Laurent Gomila

Un constructeur par défaut est celui qui ne prend pas de paramètre

Code :

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

1
2
3
4
5
6
7
class Point
{
    Point()
    {
        x = y = 0.f;
    }
};

Par exemple.

**deubelte** · 19/05/2007, 16h14

Ok merci.
Autre chose:
Dans le code suivant, il y a un compteur statique qui compte le nombre de points crées. J'ai aussi mis un descructeur qui décrémente quand on veut supprimer un point.

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
 
 
class Point{
 
private:
 
  float r,t;
public:
	static int nbpoints; 
	Point(float x ,float y);
    ~Point();
	 void affiche();
	 void deplace(float , float );
 
};
 
 int Point::nbpoints=0;
 
Point::Point(float x ,float y){++nbpoints;};
 
Point::~Point()
         {nbpoints--;};
void Point::affiche(){
cout<<nbpoints;
}
void main(){
 
Point p(2,3);
p.affiche();
Point q(2,3);
q.affiche();
 
}

le problème c'est que je ne sais pas comment supprimer un point en appelant le destructeur.( si on peut appeller un destructeur)
Par exemple, j'ai essayé Point ~p; mais ca ne marche pas.
(Ni ~p

Peut-on appeller le destructeur et si oui comment?
merci

**ac/dc** · 19/05/2007, 17h04

non le destructeur n'est pas appellé explicitement. Il est appelle implicitement lors de la destruction de ton objet (par exemple lors du delete sur un objet dynamique ...)

**Davidbrcz** · 19/05/2007, 18h11

Ou lors de la sortie du bloc dans lequel une instance de point a été crée .
Exemple

Code :

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

1
2
3
4
5
6
7
 
//...
{
Point p;
// p existe
} // sortie de bloc
// p n'existe plus.

**Bakura** · 20/05/2007, 14h57

Sinon en faisant une allocation dynamique avec un new, puis une delete :

Point * p = new Point (5, 4);

// Utilisation...

delete p; // Le destructeur est appelé.

Sinon sur ce que disait Laurent plus haut, tu peux aussi définir un destructeur avec des valeurs par défaut, comme ça ca t'evite d'écrire deux constructeurs :

// remplace ceci :
Point ();
Point (int x, int y);

// Par :
Point (int x = 0, int y = 0);

Comme ça si tu peux construire ton objet sans paramètres :

Point p; // Ici x = 0, y = 0
Point p2 (1, 2); // x = 1, y = 2

Sinon je connais pas l'utilisation de ta classe Point, mais il est peut-être plus facile de déclarer tes deux variables membres public plutôt que private, ça te permet de les modifier de n'importe où. Pour une classe vecteur mathématique par exemple, c'est plus simple, sinon ça t'oblige à créer deux fonctions pour modifier tes variables. Je trouve ça plus clair d'écrire ça :

p.x = 5;
p.y = 7;

que

p.ModifierX (5);
p.ModifierY (7);

Après à toi de voir, mais je trouve qu'il y a des cas où c'est plus pratique de déclarer tes variables mmbres public.

**Laurent Gomila** · 20/05/2007, 17h35

Sinon sur ce que disait Laurent plus haut, tu peux aussi définir un destructeur avec des valeurs par défaut, comme ça ca t'evite d'écrire deux constructeurs :

En général lorsqu'il y a plusieurs paramètres "équivalents" (càd que soit on les précise tous, soit aucun) je préfère éviter.
Ca n'aurait pas beaucoup de sens d'écrire ceci :

Code :

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