Type opaque en C

Version imprimable

02/06/2007, 23h48
Novocaine

Type opaque en C

Bonjour, je suis confronté a un probleme dans mon programme pour mon projet d'informatique.

En grandes lignes, je dois faire un jeu calqué sur Space Invader...bref.
Notre professeur nous a demandé d'appliquer un type opaque sur nos structures ; chose que j'ai faite.
Cependant, voila mon soucis:

J'ai un module projectile.c avec la definition de la structure PROJECTILE a l'interieur. Ce module gere la creation de projectile sous forme d'une liste chainée. Elle gere egalement les collisions entre elles, la suppressions de projectiles selon certaines conditions,...
J'ai aussi un module enemy.c avec la definition de la structure ENEMY. Sur le meme principe, elle gere la creation d'enemies, leur suppresions, leur dessins,...

Ce que je souhaite faire, c'est pouvoir controler la collision entre un projectile et un enemie. Je souhaite le faire a l'interieur de mon module projectile car il y a deja une fonction projectile_collision(PROJETILE** tete_robot_projectile) qui s'occupe de cela.
Mais bien entendu si j'ajoute un argument "ENEMY** tete_enemy" dans la definition de ma fonction (dans projectile.h), le compilateur me dit que ENEMY n'est pas declaré. Ce qui est normal.

Donc existe-t-il un moyen pour que je puisse faire comprendre a ma fonction que ENEMY existe bien sans devoir faire une redeclaration dans projectile.h de la structure ENEMY avec un typedef. ce qui entraine une erreur de compilation ?

Merci d'avance pour vos aides.
03/06/2007, 08h57
Bayard

Je ne suis pas sur d'avoir tout saisi...

Peut-être le mot clé

Code:

extern

peut-il aider.

Il faut poser du code (avec les balises code (c'est un #). Cela sera sans doute plus clair.

Oui, en effet, je n'ai pas été tres clair Donc voila le code:

cinematique.cpp

Code:

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <math.h>
#include "glui.h"
#include "constante.h"
 
extern "C"
{
#include "robot.h"
#include "graphic.h"
#include "projectile.h"
#include "enemy.h"
#include "rand.h"
}
[...]
static PROJECTILE* tete_robot_projectile = NULL;
static ENEMY* tete_enemy = NULL;
 
[...]
 
void idle_cb()
{
  [...]
 
  //gestion collision
  projectile_collision(&tete_robot_projectile, &tete_enemy);
 
  //gestion enemy positon
  enemy_set_position(&tete_enemy, width, height);
 
  refresh();
}

projectile.h:

Code:

1
2
3
4
5
 
typedef struct projectile PROJECTILE;
[...]
void projectile_collision(PROJECTILE** tete_projectile_robot,
			  ENEMY** tete_enemy);

projectile.c:

Code:

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
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
#include "enemy.h"
#include "projectile.h"
#include "graphic.h"
#include "robot.h"
#include "constante.h"
 
//modele de la structule PROJECTILE
struct projectile
{
  float x_projectile;
  float y_projectile;
  float vitesse;
  float delta_phi;
  PROJECTILE* projectile_suivant;
};
 
void projectile_collision(PROJECTILE** tete_projectile_robot, ENEMY** tete_enemy)
{
  PROJECTILE* pjte_compareur = *tete_projectile_robot;
 
  while(pjte_compareur != NULL)
    {
      ENEMY* enemy_courant = *tete_enemy;
      PROJECTILE* pjte_courant = pjte_compareur->projectile_suivant;
 
      //le pjte_compareur compare sa position avec celle des autres projectiles
      while(pjte_courant != NULL)
	{	
	  if(abs(pjte_compareur->x_projectile - pjte_courant->x_projectile) < DELTA_X 
	     &&
	     abs(pjte_compareur->y_projectile - pjte_courant->y_projectile) < DELTA_Y)
	    {
	      projectile_supprimer(tete_projectile_robot, pjte_compareur );
	      projectile_supprimer(tete_projectile_robot, pjte_courant);
	    } 
 
	  pjte_courant = pjte_courant->projectile_suivant;	     
	}
 
      //le pjte_compareur compare sa position avec celle des enemies
      while(enemy_courant != NULL)
	{	  
	  if(pow(pjte_compareur->x_projectile - enemy_courant->x_enemy, 2)
	     +
	     pow(pjte_compareur->y_projectile - enemy_courant->y_enemy, 2)
	     <
	     pow(R_ENEMY, 2))
	    { 
	      projectile_supprimer(tete_projectile_robot, pjte_compareur);
	       enemy_supprimer(tete_enemy, enemy_courant);
	    }
 
	  enemy_courant = enemy_courant->enemy_suivant; 
	  }
 
      pjte_compareur = pjte_compareur->projectile_suivant;
 
    }
 
}

enemy.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
 
typedef struct enemy ENEMY;
 
void enemy_creation(ENEMY** tete);
[...]
void enemy_set_position(ENEMY** tete,
			int width,
			int height);
 
void enemy_supprimer(ENEMY** tete,
		     ENEMY* enemy);

enemy.c

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
#include <stdio.h>
#include <stdlib.h>
#include <GL/glu.h>
#include <math.h>
 
#include "graphic.h"
#include "constante.h"
#include "rand.h"
#include "enemy.h"
 
//modele de la structure ENEMY
struct enemy
{
  float x_enemy;
  float y_enemy;
  float vitesse_enemy;
  ENEMY* enemy_suivant;
};

Voila, j'espere que mon probleme est un peu plus transparent.

Donc j'ai un message d'erreur lors de la compilation m'indiquant que la definition de la fonction projectile_collision(PROJECTILE**, ENEMY**) ne convient pas car il ne peut convertir ENEMY** en int**. Si j'ai bien comprit, le message survient a cause du faite que ENEMY n'est pas connu dans projectile.h

03/06/2007, 13h39
zooro
Pourquoi n'as-tu pas inclus
Code:

1 2 3 4 5 6 7 8 struct projectile { float x_projectile; float y_projectile; float vitesse; float delta_phi; PROJECTILE* projectile_suivant; };
dans le fichier .h correspondant ?
Et idem pour struct ENEMY.

C'est plus logique, et ça devrait résoudre ton problème.
03/06/2007, 14h04
Novocaine

Si je fais cela, je n'aurai plus de type opaque
03/06/2007, 14h08
Emmanuel Delahaye
Citation:
Envoyé par zooro

Pourquoi n'as-tu pas inclus

Code:

1 2 3 4 5 6 7 8 struct projectile { float x_projectile; float y_projectile; float vitesse; float delta_phi; PROJECTILE* projectile_suivant; };

dans le fichier .h correspondant ?
Et idem pour struct ENEMY.

C'est plus logique, et ça devrait résoudre ton problème.
Hum. Il s'agit de types opaques...

http://emmanuel-delahaye.developpez.com/tad.htm

C'est justement ce qu'on ne veut pas faire.
03/06/2007, 14h13
Emmanuel Delahaye

Citation:

Envoyé par Novocaine

Oui, en effet, je n'ai pas été tres clair Donc voila le code:
<...>
Donc j'ai un message d'erreur lors de la compilation m'indiquant que la definition de la fonction projectile_collision(PROJECTILE**, ENEMY**) ne convient pas car il ne peut convertir ENEMY** en int**. Si j'ai bien comprit, le message survient a cause du faite que ENEMY n'est pas connu dans projectile.h

Je ne suis pas rentré dans le détail, mais en principe, il suffit de prévoir les deux fonctions qui vont bien ('accesseurs') pour retourner la ou les données (on a le droit de faire une structure 'publique' pour ça si il y a plus d'une valeur) et appliquer sur ces données les tests qui vont bien pour déterminer si il y a collision.
03/06/2007, 16h52
Novocaine

J'ai fait un tour sur le lien que tu m'as envoyé....cependant il ne repond pas trop a mon probleme.

Lorsque tu dis qu'il faudrait prevoir une fonction adequat, je bute toujours sur la meme chose:
Si j'ecris la definition de la fonction dans mon .h et que je fais apparaitre dans les arguments une struct non-declaré, il va se planter a la compilation.
De meme si je cree un nouveau module,...

Et si je place une fonction qui retourne les valeurs de ma structure ENEMY, il me faut l'addresse du debut de la chaine, ce qui signifie un argumenent de type pointeur sur structure et donc je me retrouve dans la meme impasse.

Citation:

Envoyé par Novocaine

J'ai fait un tour sur le lien que tu m'as envoyé....cependant il ne repond pas trop a mon probleme.

Il était en réponse à zooro qui semblait ignorer la notion de données opaques... Il faut lire correctement les citations...

Citation:

Lorsque tu dis qu'il faudrait prevoir une fonction adequat, je bute toujours sur la meme chose:
Si j'ecris la definition de la fonction dans mon .h et que je fais apparaitre dans les arguments une struct non-declaré, il va se planter a la compilation.
De meme si je cree un nouveau module,...

Et si je place une fonction qui retourne les valeurs de ma structure ENEMY, il me faut l'addresse du debut de la chaine, ce qui signifie un argumenent de type pointeur sur structure et donc je me retrouve dans la meme impasse.

Bien sûr. Les types opaques ne fonctionnent qu'avec des pointeurs simples (pas de **) et ne peuvent être déréférencés hors de leur implémentation.

Il est cependant possible de créer une fonction 'à-part' nommé
Code:

1 2 3 4 collision (PROJECTILE *p_proj, ENEMY *p_enem) { }
précédée de #include "projectile.h" et de #include "ennemy.h"

qui fasse en gros ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 struct xy { int x; int y; }; struct xy xy_proj; struct xy xy_enem; projectile_get_xy (p_proj, &xy_proj.x, &xy_proj.y); enemy_get_xy (p_enem, &xy_enem.x, &xy_enem.y); if (xy_proj.x == xy_enem.x && xy_proj.y == xy_enem.y) { /* boum */ }
Ne reste plus qu'à ajouter

Code:

projectile_get_xy (PROJECTILE *self, int *px, int *py);

et

Code:

enemy_get_xy (ENEMY *self, int *px, int *py);

aux objets opaques respectifs. Je ne vois pas trop où est le problème.

NOTA : l'objet struct xy (disons XY pour rester dans ta terminologie) pourrait être un objet commun (non opaque) aux 2 objets ENNEMY et PROJECTILE, ce qui permettrait de faire ceci :

Code:

projectile_get_xy (PROJECTILE *self, XY *p_xy);

et

Code:

enemy_get_xy (ENEMY *self, XY *p_xy);

03/06/2007, 19h56
Novocaine
Citation:
Il est cependant possible de créer une fonction 'à-part' nommé

Code:

1 2 collision (PROJECTILE *p_proj, ENEMY *p_enem) { }

précédée de #include "projectile.h" et de #include "ennemy.h"
Je ne risque pas d'avoir un redefinition de mes structures ?
03/06/2007, 20h00
ITCsoft54
pour evite cela :

tu peux mettre en debut de tes fichiers entêtes :

#ifndef NOMDEFICHIER_H_
#define NOMDEFICHIER_H_

à la fin
#endif NOMDEFICHIER_H_

cela donne un truc du genre :
Code:

1 2 3 4 5 6 7 8 #ifndef NOMDEFICHIER_H_ #define NOMDEFICHIER_H_ // ton code fichier entete #endif NOMDEFICHIER_H_
03/06/2007, 21h04
gl

Citation:

Envoyé par Emmanuel Delahaye

Bien sûr. Les types opaques ne fonctionnent qu'avec des pointeurs simples (pas de **).

Sur ce point la, j'avoue ne pas vraiment comprendre l'existence de cette restriction. En quoi il est necessaire de connaitre la structure pour utiliser l'adresse d'un pointeur vers cette structure ?
Quelle est la raison de cette limitation ?
03/06/2007, 21h14
Emmanuel Delahaye

Citation:

Envoyé par gl

Sur ce point la, j'avoue ne pas vraiment comprendre l'existence de cette restriction. En quoi il est necessaire de connaitre la structure pour utiliser l'adresse d'un pointeur vers cette structure ?
Quelle est la raison de cette limitation ?

Histéorique.

Il peut exister plusieurs sortes de pointeurs (sur certaines architectures anciennes, un pointeur sur char était différend d'un pointeur sur les autres types).

Jean Marc doit avoir une réponse plus détaillée...
03/06/2007, 21h29
ITCsoft54

Une question à propos des types opaques, c'est la même chose que les Types de données abstraits ?
03/06/2007, 21h37
Emmanuel Delahaye

Citation:

Envoyé par ITCsoft54

Une question à propos des types opaques, c'est la même chose que les Types de données abstraits ?

Oui.