Fichiers hpp et structures

**insomniak** · 12/05/2006, 19h56

Bonsoir.

J'ai deux fichiers hpp :

Terrain.hpp :

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
#ifndef _CLASS_TERRAIN_H
#define _CLASS_TERRAIN_H
 
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fstream>
#include <sstream>
#include <iostream>
#include <string>
#include <vector>
#include <math.h>
 
#include "C_Case.hpp"
 
using namespace std;
 
/*
 
*/
struct Data_Decors
{
    int Base_x;//L'emplacement de sa base en x sur l'image.
    int Base_y;//l'emplacement de sa base en y sur l'image.
    int Taille_x;//Le nombre de case en x que le décors prend.
    int Taille_y;//Le nombre de case en y que le décors prend.
};
 
struct Data_Texture_Sol
{
    int Width;//La largeur d'une texture
    int Height;//La hauteur d'une texture
    int nombre_textures;//Le nombre de textures qu'il y a par chipset
};
 
 
class C_Terrain
{
private:
 
    //Taille de la map
    int LONGUEUR;
    int LARGEUR;
    int Pos_x;
    int Pos_y;
 
 
    SDL_Surface **Img_Textures_sol;
    SDL_Surface **Img_Textures_bord;
    SDL_Surface **Img_Decors;
    SDL_Surface **Img_Coffre;
    SDL_Surface **Img_Charset;
    SDL_Surface *Terrain;
 
    TTF_Font *font;
 
    void Affichage_Decors(int const x, int const y);
    void Mise_a_jour();
    //Data_Decors *Data_Decors;
    vector<Data_Texture_Sol> m_DataTextureSolList;
    class C_Case *Case;
    int clicked;
 
public:
    // Constructeur.
    C_Terrain();
 
    // Destructeur.
    ~C_Terrain();
 
    //Chargement des set
    int Init();
 
    //Chargement, Sauvegarde de maps
    int LoadMap(string fichier);
    int NewMap(int const largeur, int const longueur);
    int SaveMap(string Name);
 
    //Affichage
    void Affichage(SDL_Surface *cible);
 
    //Connaitre les données
    //Data_Decors *Get_DataDecors(int Decors);
    Data_Texture_Sol *Get_DataTextureSol(int TextureSol);
 
    //Clic sur une case
    int Clic(int const numSritex, int const numSpritey, int const xsouris, int const ysouris, int const clic);
};
 
#endif

Et Case.hpp :

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
#ifndef _CLASS_CASE_H
#define _CLASS_CASE_H
 
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>
#include <stdlib.h>
#include <stdio.h>
#include <fstream>
#include <sstream>
#include <iostream>
#include <string>
#include <vector>
#include <math.h>
 
#include "SDL_Event.hpp"
#include "C_Terrain.hpp"
 
using namespace std;
 
/*
CLASSE CASE
 
Liée à la classe C_Terrain, elle contient les informations sur la case.
*/
class C_Case
{
private:
    int affich_x;//La position x de la case
    int affich_y;//La position y de la case
    short elevation;//La hauteur de la case, positif
    int texture_sol;//La texture du sol de la case
    Data_Texture_Sol *pointeur_texture_sol;//L'adresse de la texture
    int texture_bord;//La texture du bord de la case
    int decors;//Le décors placé sur la case
    int Nr_texture;//Le Nr de la texture sur l'image
    Data_Decors *pointeur_decors;//L'adresse du décors
    int Decors_x;//la position X et Y du décors
    int Decors_y;//
    int Coffre;
    int Item;
    int PNJ;
    int Charset;
    int Angle_Charset;
    int ID;
    string Map;
 
public:
 
    SDL_Events *Events;
    class C_Terrain Terrain();
    // Constructeur.
    C_Case(SDL_Events &Event);
 
    // Destructeur.
    ~C_Case();
 
    int Get_TextureSol();
    void SetData(string buf, int pos_x, int pos_y);
    //Clic sur une case
    int Clic();
};
 
#endif

Mais lors de la compilation, ça plante à la ligne de Case.hpp :

Code :

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

1
2
 
Data_Texture_Sol *pointeur_texture_sol;

'ISO forbids declaration of Data_Texture_Sol with no type'

En gros, le compilateur ne voit pas Data_Texture_Sol se trouvant dans Terrain.hpp. Pourquoi ?

Je travaille sous Code::Blocks.
Ne vous étonnez pas si le code est sal et étrange, je suis en train de remodeler mon programme.

En attendant votre réponse

**reggae** · 12/05/2006, 20h03

Pourquoi des ".hpp"? Les ".h" conviennent très bien me semble-t-il.

**Laurent Gomila** · 12/05/2006, 20h04

Tu as des inclusions cycliques, ce que tu peux a priori éviter en plaçant tes structures Data_Decors et Data_Texture_Sol dans un en-tête séparé. Tu peux aussi simplement faire des déclarations anticipées, puisque tu ne déclares que des pointeurs.
Voir la FAQ C++ pour plus de détails.

**Laurent Gomila** · 12/05/2006, 20h05

Envoyé par reggae

Pourquoi des ".hpp"? Les ".h" conviennent très bien me semble-t-il.

.hpp est très utilisé (voir boost par exemple, ou la VCL). Ca n'a rien d'illogique, par rapport au couple .c / .cpp...

**insomniak** · 12/05/2006, 20h16

Envoyé par Laurent Gomila

Tu as des inclusions cycliques, ce que tu peux a priori éviter en plaçant tes structures Data_Decors et Data_Texture_Sol dans un en-tête séparé. Tu peux aussi simplement faire des déclarations anticipées, puisque tu ne déclares que des pointeurs.
Voir la FAQ C++ pour plus de détails.

Hum... Qu'est-ce que des inclusions cycliques ?

Et je suis passé par la FAQ avant de poster, mais j'ai pas trop compris comment régler le problème... Surtout que j'aparemment ça devrait fonctionner.

**Laurent Gomila** · 12/05/2006, 20h37

Hum... Qu'est-ce que des inclusions cycliques ?

Terrain.hpp inclue Case.hpp qui inclue Terrain.hpp qui inclue Case.hpp qui inclue Terrain.hpp qui inclue Case.hpp qui inclue Terrain.hpp qui inclue Case.hpp qui inclue Terrain.hpp qui inclue... Au bout d'un moment le compilateur s'arrête, et en général à ce moment il te sort également une erreur du genre de celle que tu as.

Et je suis passé par la FAQ avant de poster, mais j'ai pas trop compris comment régler le problème... Surtout que j'aparemment ça devrait fonctionner.

Je te l'ai dit, et la FAQ aussi, il suffit d'utiliser des déclarations anticipées au lieu d'inclure les en-têtes.

**insomniak** · 12/05/2006, 20h43

Désolé mais j'ai du mal à comprendre... La FAQ n'est pas très claire... En effet, dans A.h, il inclut la class B, or comment le compilateur peut-il la trouver sans inclure le fichier b.h ?? J'ai vraiment du mal à comprendre....

Merci de m'aider en tout cas

**Laurent Gomila** · 12/05/2006, 20h46

Justement il n'a pas à la trouver, puisqu'on n'en déclare qu'un pointeur (un pointeur sur A ou un pointeur sur Tartanpion, au niveau déclaration c'est pareil pour le compilo). Donc on peut se contenter de dire au compilo que notre classe existe et qu'elle sera incluse plus tard.

**insomniak** · 12/05/2006, 20h49

Or, dans le cas présent, ou est-elle donc incluse ?? Dans le fichier .cpp ??

**Laurent Gomila** · 12/05/2006, 20h52

Voilà. Ca suffit pour casser le cycle d'inclusions.

**insomniak** · 12/05/2006, 21h05

Une derniere question : du coup je suis obligé de le déclarer en tant que class ?

**Laurent Gomila** · 12/05/2006, 21h09

Envoyé par insomniak

Une derniere question : du coup je suis obligé de le déclarer en tant que class ?

Non, tu peux faire une déclaration anticipée d'une structure.

**insomniak** · 12/05/2006, 21h25

En fait, c'était pas ma derniere question...

J'ai un petit problème, ma classe Case est déclarée dans Terrain, et je veux que chacune des Case déclarées dans Terrain possède un pointeur vers le meme Terrain.

En gros, pour

Code :

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

1
2
3
4
class Terrain
{
    C_Case Case[100];
};

et

Code :

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

1
2
3
4
C_Case
{
    class Terrain *Terrain;
}

Il faudrait que le pointeur Terrain soit toujours vers la classe déclarée dans le main... Comment faire?

**Matthieu Brucher** · 12/05/2006, 22h19

Passer le pointeur à la contruction de l'objet.

**insomniak** · 13/05/2006, 09h01

J'y ai pensé, mais dans ce cas, il faudrait que je passe le pointeur sur Terrain.pTerrain quand je le déclare Terrain dans le main, puis que je passe ce que contient pTerrain dans la construction de Case ? C'est un peu sale comme technique... non ?

**Laurent Gomila** · 13/05/2006, 09h05

De toute façon ce ne sera pas possible, puisque tu as un tableau de Case, elles seront donc forcément construites par défaut.

Tu peux donc faire une fonction membre Case::SetTerrain(Terrain* Ptr), au pire. Mais pourquoi les cases ont-elles besoin du pointeur sur le terrain ? Ca me semble une erreur de conception.

**insomniak** · 13/05/2006, 09h35

Dans mon programme, je set les données des différentes texture dans la classe Terrain, donc j'aurais besoin d'y accéder avec quelquechose dans le genre :

Code :

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

m_pTerrain->Get_DataTextureSol(m_Sprites[SOL]);

Mais en fait, je vais peut-etre faire ça autrement je pense...

Au passage, la STL m'interresse beaucoups, et j'ai étudié un peu map.

Est-ce que l'utilisation de map avec des Enums peut remplacer des structures ?

Code :

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

1
2
    enum {SOL = 0, BORD = 1, ELEVATION = 2, DECORS = 3, COFFRE = 4, CHARSET = 5};
    map<int, int> m_Sprites;

Puis... m_Sprites[SOL]=2 par exemple...

Merci d'avance.

**Laurent Gomila** · 13/05/2006, 09h40

std::map est une table asociative, donc globalement tu vas l'utiliser lorsque tu vas avoir besoin d'associer des données à des clés, et de faire des accès par ces clés.
Après, ton exemple est trop vague pour dire si c'est un bon cas d'utilisation ou non ; il faudrait détailler ce que tu associes à tes clés et la manière dont tu utilises tout ça.

**insomniak** · 13/05/2006, 09h45

En fait, je voudrais me servir de map pour stocker toute les données concernant l'affichage des sprites sur ma case.
Car je stocke dans m_Sprites les numéro des images chargées pour le SOL, le BORD, le DECORS, ect... Ca me semble pas mal, et surtout plus propre, mais est-ce une bonne utilisation ?? Je me suis inspiré du code source du jeu Wesnoth...

**Laurent Gomila** · 13/05/2006, 10h00

Oui, là ça paraît effectivement plus propre.

Fichiers hpp et structures

C++

Discussions similaires

Partager

Partager