Discussion :

[s-ehtp]

Bonjour,
j'ai à créer un code pour verifier si deux points a et b par exemple coincide.
coincide est une fonction membre de ma classe Point.Et je dois passer mon objet par pointeur sur cette methode...le code est le voila:

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
#include<iostream.h>
class Point{
private:
	int x,y;
public:
	Point(int abs=0,int ord=2)
	{x=abs;
	 y=ord;
	}//constructeur
	int coincide(Point*);
 
};
 
int Point::coincide(Point *pt)
{  pt=new Point;
	if((pt->x==x)&&(pt->y==y))
		return 1;
	else 
		return 0;
}
int main()
{ 
  int test1,test2;
  Point a;
  Point b(1);
  test1=a->coincide(b);
  test2=b->coincide(a);
  cout<<"a et b:"<<test1<<"ou"<<test2<<endl;
  return 0;
}

Et lors de la compilation voila les erreurs que j'obtiens:

Compiling...
coincide.cpp
C:\Documents and Settings\salma\Bureau\Tp C++\coincide.cpp(26) : error C2819: type 'Point' does not have an overloaded member 'operator ->'
C:\Documents and Settings\salma\Bureau\Tp C++\coincide.cpp(2) : see declaration of 'Point'
C:\Documents and Settings\salma\Bureau\Tp C++\coincide.cpp(26) : error C2227: left of '->coincide' must point to class/struct/union
C:\Documents and Settings\salma\Bureau\Tp C++\coincide.cpp(27) : error C2819: type 'Point' does not have an overloaded member 'operator ->'
C:\Documents and Settings\salma\Bureau\Tp C++\coincide.cpp(2) : see declaration of 'Point'
C:\Documents and Settings\salma\Bureau\Tp C++\coincide.cpp(27) : error C2227: left of '->coincide' must point to class/struct/union
Error executing cl.exe.

j'attend vos commentaires!
Merci,
cordialement!

[koala01]

Salut,

Déjà, je ne comprend pas trop pourquoi tu demande une nouvelle allocation dynamique pour ton pointeur avant de tester si l'élément tout nouvellement créé coïncide avec l'élément en cours...

En plus, tu déclare ton argument comme... étant un pointeur sur un élément de type point, mais, dans ta fonction main(), tu as deux instances de types Point, et non deux pointeurs sur des éléments de type point

D'ailleurs, il n'est absolument pas nécessaire de passer par des pointeur dans ton histoire, ou alors, je n'ai vraiment pas compris le principe.

Il faut bien comprendre que l'acces à un membre d'instance sous la forme de -> ne peut s'effectuer que quand on dispose d'un pointeur.

Quand on dispose d'une instance normale, il faut utiliser . (ex: a.coincide(/*...*/)

Ainsi, je te conseillerais fortement de passer l'argument plutot sous la forme d'une référence, et plus précisément sous la forme d'une référence constante (pour indiquer que tu t'engage à ne pas modifier l'objet passé en paramètre)

Au final, le code "idéal" serait plutot du genre de

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
#include<iostream.h>
class Point{
private:
	int x,y;
public:
	Point(int abs=0,int ord=2)
	{x=abs;
	 y=ord;
	}//constructeur
        /* *Idéalement*, la méthode et la référence devraient être constante
         * mais on peut *envisager* de travailler sans veiller à la "const-correctness"
         */
	int coincide(/*const*/ Point&);/*const*/
 
};
 
int Point::coincide(/*const*/ Point &pt) /* const */
{ 
        /* les parenthèses entourant les tests d'égalité ne sont absolument
         * pas indispensables, et sont à l'extrême limite contre productives
         * dans ce cas précis (étant donné qu'il n'y a aucune ambiguité sur
         * l'ordre d'exécution ;))
         */
	if(pt.x==x && p.y==y)
		return 1;
	else 
		return 0;
}
int main()
{ 
  int test1,test2;
  Point a;
  Point b(1);
  test1=a.coincide(b);
  test2=b.coincide(a);
  cout<<"a et b:"<<test1<<"ou"<<test2<<endl;
  return 0;
}

Si tu tiens à passer un pointeur comme argument, mais que tu ne veux pas effectuer une allocation dynamique pour a et b dans ta fonction principale, le code deviendrait

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
#include<iostream.h>
class Point{
private:
	int x,y;
public:
	Point(int abs=0,int ord=2)
	{x=abs;
	 y=ord;
	}//constructeur
        /* ici aussi, l'idéal serait de déclarer l'argument et la fonction constant(e)s
         * mais on peut toujours envisager de jeter la "const-correctness" aux
         * ortilles :D
         */
	int coincide(/*const*/ Point*) /*const*/;
 
};
 
int Point::coincide(/*const*/ Point *pt) /*const*/
{  /* pt=new Point; ne sert strictement à rien */
        /* la remarque précédente concernant les parenthèses reste valable ;)*/
	if(pt->x==x && pt->y==y )
		return 1;
	else 
		return 0;
}
int main()
{ 
  int test1,test2;
  Point a;
  Point b(1);
  test1=a.coincide(&b);
  test2=b.coincide(&a);
  cout<<"a et b:"<<test1<<"ou"<<test2<<endl;
  return 0;
}

Il est à noter que, *idéalement*, il faudrait vraiment utiliser un argument constant et rendre la méthode constante, de manière à "t'engager envers le compilateur" à ce que la méthode ne modifie pas l'élément en cours

Enfin, avec la classe déclarée comme dans mon deuxième exemple, tu peux envisager de créer tes objet a et b de manière dynamique dans ta fonction principale...

Cela prendrait alors la forme de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main()
{ 
  int test1,test2;
  /* on crée dynamiquement les deux points */
  Point *a=new Point;
  Point *b=new Point(1);
  test1=a->coincide(b);
  test2=b->coincide(a);
  cout<<"a et b:"<<test1<<"ou"<<test2<<endl;
  /* mais il ne faut alors pas oublier d'en libérer la mémoire */
  delete a;
  delete b; 
  return 0;
}