Programmation modulaire et SDL (langage C)

[Oragon]

Bonjour !

Je n'arrive pas à atteindre mes objets à partir de mes en-têtes... tjrs le même "undefined reference to....". pourtant je pense bien faire.
Je déclare mes variables dans "monheader.h" et je les utilises dans "monmodule.c" et "principal.c" sans oublier d'écrire dans ces derniers l'include de "monheader.h" c'est bien ça ? :00000002:

alors y-a-til quelquechose de plus a faire pour la programmation modulaire avec SDL ou suis-je nul ? ^^

J'attends vos réponses, merci.
Oragon

[asmanur]

Deja ca n'a aucun rapport avec SDL.
Ensuite quel IDE utilises tu, cela vient peut-etre du fait que tu n'as pas créé de proejt ou que tes fichiers .c ne sont pas inclus dedans, vérifié deja ca

[Oragon]

Ok donc chui pas sur la bonne section, lol.
J'utilise Devcpp.
mes fichiers c sont bien inclus...

je donne ici un exemple inutile mais bon... ça montre ma démarche.
//mon header
int carre(void);
int variable;
int valeur;

//mon module
#include "monheader.h"
int carre(void)
{
return variable*variable;
}

//mon fichier principal
#include "mon header.h"
main()
{
variable=4;
valeur=carre();
return 0;
}

[ZeBlueCow]

:00000005: bizzare ton code... mais dans l'esprit c'est ça... un en-tête avec les prototypes de tes fonctions (mais c'est pas encore des objets, hein :00000020: )... par contre tes variables en en-tête ça me dépasse : pkoi tu utilise pas les paramètres de tes fonctions ???

ex.
//mon header
int carre(int);

//mon module
#include "monheader.h"
int carre(int variable)
{
return variable*variable;
}

//mon fichier principal
#include "mon header.h"
main()
{
int valeur;
valeur=carre(4);
return 0;
}

dans le cas où tu souhaites garder tes variables en entête, tu dois les mettre en global, çàd les définir dans un seul fichier et utiliser "extern" dans tous les autres, mais je n'en vois pas l'intérêt ici...

ex.
//mon header
int carre(void);


//mon module
#include "monheader.h"
extern variable;
int carre(void)
{
return variable*variable;
}

//mon fichier principal
#include "mon header.h"
int variable, valeur;
main()
{
variable = 4;
valeur=carre();
return 0;
}

[Oragon]

Ouai nan je sais que mon code ici est inutile. c'est juste pour montrer. j'ai voulu mettre une variable en en-tête, même si c'est stupide ici, pour savoir comment faire pour le récuperer après ailleurs.

en fait moi concrètement je déclare ma surface sdl dans l'entête car faut bien je la déclare quelque part. il s'agit d'un pointeur. pour la réutiliser ailleurs je fais juste "extern SDL_Surface *ma_surface" dans ma fonction et je peux l'y utiliser, c'est ça ?

[MrCool]

Si tu souhaites récupérer le pointeur vers l'écran, il est plus propre d'utiliser cette fonction:


SDL_Surface *SDL_GetVideoSurface(void);


Pour le reste, on ne déclare *jamais* de variable globale dans un .h
En effet, si tu inclus deux fois ton header, tu auras une erreur puisque tu vas créer deux fois une variable avec le même nom.

On met dans le header la ligne:


extern <type> <ma var globale>;


Et dans ton fichier c, tu peux déclarer ta variable avec la syntaxe suivante:


<type> <ma var globale>;



De plus, c'est une mauvaise idée d'utiliser les variables globales dans la plupart des cas. Je te conseille de créer tes propres types (struct ou classe selon le langage utilisé) et de passer un pointeur vers ces données.

Par exemple une structure struct s_surf_mgr qui pourrait être une liste chaînée de surface, un tableau ou qqc du genre. Ensuite, pour chaque fonction, tu peux passer un pointeur vers cette structure.


Dernière chose: si cela t'embête de mettre un argument fixe dans toutes les fonctions de ton jeu (dans notre cas le pointeur vers ta structure s_surf_mgr).

Tu peux faire ceci:


#include <stdlib.h>

static struct s_surf_mgr *getset_surf_mgr(struct s_surf_mgr *nptr, int new)
{
static struct s_surf_mgr *ptr = NULL;

if (new)
ptr = nptr;
return ptr;
}

extern struct s_surf_mgr *get_surf_mgr(void)
{
return getset_surf_mgr(NULL, 0);
}

extern struct s_surf_mgr *set_surf_mgr(struct s_surf_mgr *nptr)
{
return getset_surf_mgr(nptr, 1);
}



Ce morceau de code permet de créer un comportement similaire à la fonction SDL_GetVideoSurface(void).

Tant que tu n'as pas appellé set_surf_mgr(), get_surf_mgr() renvoit NULL. Une fois que tu as appellé set_surf_mgr() avec un pointeur X alors get_surf_mgr() renverra le pointeur X.


Je trouve personnellement que cette solution est plus élégante qu'une variable globale dans le cas où on a constamment besoin de certains pointeurs.

NB: en C++ je suppose qu'une méthode plus approprié serait un singleton.

[Oragon]

ok, j'ai compris mtnt. merci.