Partage

Problème de classe

Sujet résolu

rrazpo

18 août 2007 à 3:10:58

Bonjour à tous

(ou plutot bonsoir :-°

)

Voilà, je débute dans le langage C++, et j'ai encore du mal avec les classes.

Mon petit projet est de crée un snake en utilisant un maximum la POO (sinon autant coder le jeu en C).

J'ai donc pensé a crée une classe serpent.

Puis j'ai réflechis, et je me suis dit qu'une classe graphique, permettant de s'occuper de toute la partie graphique du jeu en testant toutes les fonctions SDL pour qu'il n'y ait plus de problème serais une super idée.

J'ai donc commencé à la coder, lorsque je me suis dit qu'une classe erreur, permettant de géré toutes les erreurs de la partie graphique (et peut être d'autres classes ^^) et de les écrire sur un fichier erreur serais aussi une bonne idée.

Ce qui me donne ceci :

#ifndef DEF_GRAPHIQUE
#define DEF_GRAPHiQUE
class Graphique
{
public :
Graphique();
private :
SDL_Surface *m_ecran;
void InitialiseEcran(SDL_Surface *m_ecran);
};
#endif

#include <SDL/SDL.h>
#include <string>
#include "constantes.h"
#include "erreur.h"
#include "graphique.h"
using namespace std;
Graphique::Graphique()
{
Graphique::InitialiseEcran(m_ecran);
}
void Graphique::InitialiseEcran(SDL_Surface *ecran)
{
ecran=SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
if(ecran!=NULL)
{
Erreur::erreur(ECRAN); /*ligne qui bug*/
}
}

#ifndef DEF_ERREUR
#define DEF_ERREUR
class Erreur
{
public :
Erreur();
void erreur(int erreur);
private :
std::string m_chaine;
void ecriture_erreur(int erreur);
};
#endif

#include <iostream>
#include <string>
#include "erreur.h"
#include "graphique.h"
#include "constantes.h"
using namespace std;
Erreur::Erreur()
{
}
void Erreur::erreur(int erreur)
{
Erreur::ecriture_erreur(erreur);
}
void Erreur::ecriture_erreur(int erreur)
{
FILE *fichier=fopen("erreur.txt","w");
if(fichier != NULL)
{
switch(erreur)
{
case ECRAN:
m_chaine=" la creation de la surface ecran";
break;
default:
break;
}
fprintf(fichier,"Problème avec %s",m_chaine);
fclose(fichier);
}

Malheuresement cela ne compile pas.

Apparement je ne peut pas avoir accès a la fonction erreur de la classe Erreur. Et je ne comprend pas pourquoi o_O

Voici ce que me crie mon compilo :

Citation : Mon compilo

graphique.cpp:20: error: cannot call member function `void Erreur::erreur(int)' without object
:: === Génération finie: 1 erreurs, 0 avertissements ===

Que dois je faire docteur ? :euh:

[Kansuu]

18 août 2007 à 4:25:30

Je comprend pas ce que tu veux faire là:

Erreur::erreur(ECRAN); /*ligne qui bug*/

Tu appele le constructeur comme si tu appelerais une fonction, faut pas faire ça.
De là ton erreur tu appele une fonction sans objet.
En gros tu devrais créer une classe erreur dans ta clase graphique;

Erreur erreur;

Ensuite tu n'a qua faire

erreur.erreur(ECRAN);

(Bien sur faut créer une fonction appeler erreur, et non utilisé le constructeur)

psychoh13

18 août 2007 à 4:35:45

Je vois deux problèmes personnellement. Le premier majeur, le deuxième très simple.

Commençons par le simple, il concerne l'erreur :

graphique.cpp:20: error: cannot call member function `void Erreur::erreur(int)' without object

:: === Génération finie: 1 erreurs, 0 avertissements ===

Pour résoudre ce problème il suffit de lire. Tu ne peux pas faire d'appel à une fonction membre sans utiliser un objet. Pour pouvoir faire ce que tu veux, il faut écrire ça :

Erreur uneErreur;
uneErreur.erreur(ERREUR);

Je te conseille de remplacer ton système par la gestion d'exception qui est plus efficace et plus logique. Tu peux aussi utiliser le flux "cerr" qui fonctionne comme "cout" pour récupérer les erreurs. Dans les deux cas, ta classe Erreur n'a pas lieu d'être.

Le problème majeur concerne l'initialisation de ta classe graphique.

#ifndef DEF_GRAPHIQUE
#define DEF_GRAPHiQUE
class Graphique
{
public :
Graphique();
private :
SDL_Surface *m_ecran;
void InitialiseEcran(SDL_Surface *m_ecran);
};
#endif

#include <SDL/SDL.h>
#include <string>
#include "constantes.h"
#include "erreur.h"
#include "graphique.h"
using namespace std;
Graphique::Graphique()
{
Graphique::InitialiseEcran(m_ecran);
}
void Graphique::InitialiseEcran(SDL_Surface *ecran)
{
ecran=SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
if(ecran!=NULL)
{
Erreur::erreur(ECRAN); /*ligne qui bug*/
}
}

Pour commencer, je ne comprends pas l'intérêt d'avoir une méthode d'initialisation alors que le constructeur est là pour ça ! Ensuite il faut que tu révises le cours sur les pointeurs.
Un pointeur est une variable comme une autre. Si tu passes un pointeur à une fonction et que tu modifies la valeur du pointeur (c'est-à-dire la zone qu'il pointe en mémoire), la modification ne sera pas répercuter dans la fonction appelante !
En clair ce que tu fais là :

ecran=SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);

N'a aucun effet sur la variable m_ecran de ton objet !
Si tu tiens vraiment à utiliser une méthode d'initialisation privée, il faut tout simplement utiliser le pointeur this.

Voilà la forme que vont prendre tes fonctions :

Graphique::Graphique()
{
this->InitialiseEcran();
}
void Graphique::InitialiseEcran(void)
{
m_ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
if(m_ecran == NULL) // tu t'étais trompé là-dessus !
{
// Utilise ici le mécanisme des exceptions.
}
}

C'est bien que tu tiennes à exploiter la programmation objet à fond, mais si tu veux le faire, fais-le vraiment ! Ta façon de construire la méthode d'initialisation prouve que tu n'as pas saisi le concept à fond.

rrazpo

18 août 2007 à 13:05:22

Citation : Psychoh10

Je te conseille de remplacer ton système par la gestion d'exception qui est plus efficace et plus logique.

Je ne sais pas ce que c'est, pourrais tu m'en dire plus ?

Citation : Psychoh13

Tu peux aussi utiliser le flux "cerr" qui fonctionne comme "cout" pour récupérer les erreurs. Dans les deux cas, ta classe Erreur n'a pas lieu d'être.

Oui c'est vrai, mais en plus de me former à la POO, j'ai plus de plaisir a réinventer la roue que de l'utiliser :-°

Citation : Kansuu

En gros tu devrais créer une classe erreur dans ta clase graphique;

C'était bien ça, merci

Citation : Psychoh13

Si tu tiens vraiment à utiliser une méthode d'initialisation privée, il faut tout simplement utiliser le pointeur this.

Je ne veut pas "absolument" utilisé une initialisation privé, je voulais juste pouvoir tester si la création de l'écran c'était bien passé. Et je ne pensait pas qu'on puisse le faire dans un constructeur, je me suis trompé ?

Quand au pointeur this, je ne vois pas en quoi il est indispensable ? (surtout que mathéo n'explique que très peu de chose dessus, je sais juste qu'il pointe sur l'objet o_O

Citation : Psychoh13

Voilà la forme que vont prendre tes fonctions :

J'ai tout lachement copié ( :-°

), et je me retrouve avec une autre erreur.

Apparement, mon compilo ne reconnais pas la classe Erreur.

Citation : Mon compilo

graphique.h:13: error: `Erreur' does not name a type
:: === Génération finie: 1 erreurs, 0 avertissements ===

Voici ma classe graphique :

#ifndef DEF_GRAPHIQUE
#define DEF_GRAPHiQUE
class Graphique
{
public :
Graphique();
private :
SDL_Surface *m_ecran;
Erreur monErreur;
void InitialiseEcran(void);
};
#endif

#include <SDL/SDL.h>
#include <string>
#include "constantes.h"
#include "erreur.h"
#include "graphique.h"
using namespace std;
Graphique::Graphique()
{
this->InitialiseEcran();
}
void Graphique::InitialiseEcran(void)
{
m_ecran=SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
if(m_ecran!=NULL)
{
monErreur.erreur(ECRAN);
}
}

Citation : Psychoh13

C'est bien que tu tiennes à exploiter la programmation objet à fond, mais si tu veux le faire, fais-le vraiment ! Ta façon de construire la méthode d'initialisation prouve que tu n'as pas saisi le concept à fond.

Oui, je n'ai pas saisi encore comment cela marche vraiment, mais justement, rien ne vaut la pratique d'après moi

PS: Ce n'était pas une erreur ici :

if(m_ecran == NULL) // tu t'étais trompé là-dessus !

Je l'avais fait exprès pour voir si je réussisait bien à crée mon fichier erreur avec écris dessus la cause de l'erreur.

psychoh13

18 août 2007 à 13:35:47

Citation : rrazpo

Citation : Psychoh10

Je te conseille de remplacer ton système par la gestion d'exception qui est plus efficace et plus logique.

Je ne sais pas ce que c'est, pourrais tu m'en dire plus ?

La gestion des exceptions est un système très pratique permettant de récupérer les erreurs à la volée , lorsqu'elles interviennent. En général, on crée son propre type d'exception qui hérite de la classe Exception de la SL C++. On crée même une classe pour chaque type d'erreur qui interviennent, mais on peut aussi améliorer ce mécanisme, tout est possible.

EN gros, lorsqu'une erreur apparaît on "lève" (raise/throw) une exception. Pour lancer une exception on utilise le mot clé "throw" de cette façon :

if(monObjet == NULL)
{
throw MyException("Création de l'objet invalide");
}

La classe MyException peut se définir très simple :

class MyException
{
public:
MyException(char * m) { message = m; }
char * getMessage() { return message; }
private:
char * message;
};

Pour pouvoir gérer les exceptions il faut mettre dans un bloc try...catch les instructions à risque :

try {
MyRiskyMethod();
}
catch (MyException e)
{
// traitement spécifique à l'erreur prévue, exemple, affichage du message :
cout << e.getMessage() << endl;
}
catch (Exception e)
{
// autre agent pour récupérer les méthodes qu'on ne sait pas traiter
}

Un bloc try {} est toujours directement suivit d'un ou plusieurs bloc catch() {}, un bloc catch() est toujours précédé d'un bloc try {} ou d'un bloc catch() qui lui est précédé d'un try {}. Tu peux donc créer autant d'agent de récupération d'exception. Sachant que le premier agent qui sait récupérer l'exception est employé et donc le reste ignoré... Si tu fais des classes exception héritant de l'Exception de la SL et que tu mets un catch (Exception e) en premier, toutes les exceptions atterriront dans ce premier bloc, et donc les gestions spécifiques que tu as programmé après seront toutes ignorées...

Citation : rrazpo

Oui c'est vrai, mais en plus de me former à la POO, j'ai plus de plaisir a réinventer la roue que de l'utiliser

Il faut faire attention, car la roue bien qu'innocente dans sa rondeur est un outil complexe...

Citation : rrazpo

Je ne veut pas "absolument" utilisé une initialisation privé, je voulais juste pouvoir tester si la création de l'écran c'était bien passé. Et je ne pensait pas qu'on puisse le faire dans un constructeur, je me suis trompé ?

Le constructeur est une méthode comme une autre, à la différence qu'elle ne retourne rien, mais tu peux faire absolument tout ce que tu veux dedans. Tu y appelles bien une méthode d'initialisation, pourquoi tu ne pourrais directement appeler une fonction ?

Citation : rrazpo

Quand au pointeur this, je ne vois pas en quoi il est indispensable ? (surtout que mathéo n'explique que très peu de chose dessus, je sais juste qu'il pointe sur l'objet ).

Le pointeur this représente l'objet sur lequel on a appelé la méthode :

monObjet.maMethode();

Dans la méthode "maMethode()", this sera donc ici un pointeur sur l'objet "monObjet", si en l'occurrence je l'ai utilisé, c'est tout simplement parce que l'initialisation doit se faire sur l'objet en construction, il est donc logique que la méthode soit appelé sur l'objet lui-même, donc this est nécessaire.

Citation : rrazpo

J'ai tout lachement copié ( ), et je me retrouve avec une autre erreur.

Apparement, mon compilo ne reconnais pas la classe Erreur.

Citation : Mon compilo

graphique.h:13: error: `Erreur' does not name a type
:: === Génération finie: 1 erreurs, 0 avertissements ===

Voici ma classe graphique :

#ifndef DEF_GRAPHIQUE

#define DEF_GRAPHiQUE

class Graphique

{

public :

Graphique();

private :

SDL_Surface *m_ecran;

Erreur monErreur;

void InitialiseEcran(void);

};

#endif

Si j'en crois ton code, lorsque le compilateur regarde l'interface de ta classe il tombe sur un objet dont il n'a aucune connaissance : Erreur. Il faut que tu inclues dans le fichier d'interface de ta classe (donc le .h) le fichier d'interface de tes erreurs (donc le Erreur.h doit être inclut dans Graphique.h).

rrazpo

18 août 2007 à 14:20:17

Citation : Psychoh13

La gestion des exceptions est un système très pratique permettant de récupérer les erreurs à la volée , lorsqu'elles interviennent. En général, ....

Je vais bien prendre le temps de comprendre, car c'est assez compliqué a lire :euh:

Citation : Psychoh

Il faut faire attention, car la roue bien qu'innocente dans sa rondeur est un outil complexe...

Et pourtant, c'est en menuisant qu'on devien menuisier

(comment ça c'est nul comme métaphore ?

)

Citation : Psychoh13

Le constructeur est une méthode comme une autre, à la différence qu'elle ne retourne rien, mais tu peux faire absolument tout ce que tu veux dedans. Tu y appelles bien une méthode d'initialisation, pourquoi tu ne pourrais directement appeler une fonction ?

A oui, je n'avais pas pensé a ça. Pour moi le constructeur se devait d'initiliser toutes ses variables hors des deux accolades :-°

Citation : Psychoh

Si j'en crois ton code, lorsque le compilateur regarde l'interface de ta classe il tombe sur un objet dont il n'a aucune connaissance : Erreur. Il faut que tu inclues dans le fichier d'interface de ta classe (donc le .h) le fichier d'interface de tes erreurs (donc le Erreur.h doit être inclut dans Graphique.h).

J'ai donc inclus erreur.h dans graphque.h (ça fais bizarre d'inclure dans des fichier.h :euh:

) et pour être cohérent j'ai inclus aussi SDL/SDL.h. Sauf que maintenant mon compilo me dis :

Citation : Mon compilo

erreur.cpp:36: warning: cannot pass objects of non-POD type `struct std::string' through `...'; call will abort at runtime
:: === Génération finie: 0 erreurs, 1 avertissements ===

C'est pas simple la POO.... :lol:

lmghs

18 août 2007 à 15:41:21

Remarques:
Psychoh13,
- tes signatures ne sont pas bonnes (pas const correct, ni pas compatible avec une dérivation depuis std::exception)
- des fuites de mémoire ou autre dangling pointer dans des utilisations types d'une classe d'exception (genre qui réçoit le résultat d'une std::string::c_str())
- la classe de la SL est std::exception (en minuscules -- hors macros, il n'y a qu'un (ou deux) identifiant(s) avec une majuscule dans la SL
- autant dériver de std::runtime_error qui gère déjà correctement la mémoire, et qui est prévue pour les erreurs liées au contexte d'exécution.
- Attraper les exceptions par recopie de valeur est une pratique déconseillée

Bref, plus par là: http://c.developpez.com/faq/cpp/?page=exceptions

Sinon,
Le fait de na pas pouvoir passer de données complexes dans l'ellipse (...) n'a rien à voir avec la POO. C'est une limitation qu'avait déjà le C. Utilise les flux du C++ au lieu de continuer à employer la SL du C.

rrazpo

18 août 2007 à 16:00:41

Citation : lmghs

Sinon,
Le fait de na pas pouvoir passer de données complexes dans l'ellipse (...) n'a rien à voir avec la POO. C'est une limitation qu'avait déjà le C. Utilise les flux du C++ au lieu de continuer à employer la SL du C.

Si cette remarque s'adresse a moi, je dois t'informer que je n'ai absolument rien compris. :-°

lmghs

18 août 2007 à 16:13:08

Oui, c'est bien pour toi. N'envoie pas une std::string, ou plus généralement quoique ce soit qui ne soit pas un type numérique de base, ni pointeur vers un buffer 0-terminé de caractères, dans une fonction qui contient 3 points (aka "ellipse") dans sa signature. En particulier tous les *printf()

rrazpo

18 août 2007 à 18:08:54

Citation : lmghs

Oui, c'est bien pour toi. N'envoie pas une std::string, ou plus généralement quoique ce soit qui ne soit pas un type numérique de base, ni pointeur vers

Ca ça va

Citation : lmghs

un buffer 0-terminé de caractères

Gné

Citation : lmghs

dans une fonction qui contient 3 points (aka "ellipse") dans sa signature.

3 points ? Par exemple :

fprintf(/*1*/fichier,/*2*/"texte numéro : %d ",/*3*/numero);

Citation : lmghs

En particulier tous les *printf()

Apparement, il est déconseillé d'utiliser les string avec les fonctions de type printf, je dois utiliser quoi alors pour pouvoir écrire dans un fichier ?

Anonyme

18 août 2007 à 20:37:50

Un buffer 0-terminé de caractères, c'est un tableau de char se terminant par un 0 ou '\0', autrement dit, une chaîne de caractères. Quand il veut dire 3 points (...), ce sont les 3 points que tu vois dans le prototype de printf ou celui de scanf par exemple:

int printf (const char *format, ...);
int scanf (const char *format, ...);

Ces trois points sont ce qu'on appelle une ellipse : cela signifie que la fonction peut admettre un nombre aussi grand que l'on veut d'arguments (le minimum est 1 en l'occurence).

Pour écrire et lire dans les fichiers en C++, tu as ce tuto.

psychoh13

18 août 2007 à 22:47:54

Il faut m'excuser en ce qui concerne la gestion des exceptions ça fait longtemps que je n'en ai pas fait en C++...
Désolé

rrazpo

19 août 2007 à 15:23:00

Citation : Cyprien_

Pour écrire et lire dans les fichiers en C++, tu as ce tuto.

Vraiment très utile ce tuto merci

J'ai encore un problème de classe :-°

Je crée dans ma classe graphique un objet de classe image, puis j'utilise une fonction interface de la classe image, mais cela m'indique que la classe n'est pas connus.

Etrange surtout que j'inclus bien la classe image o_O

#ifndef DEF_IMAGE
#define DEF_IMAGE
#include <SDL/SDL.h>
class Image
{
public :
Image();
void chargerImage(int image);
private :
SDL_Surface *m_image;
};
#endif

#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include "image.h"
#include "graphique.h"
#include "constantes.h"
Image::Image()
{
m_image=NULL;
}
void Image::chargerImage(int image)
{
switch(image)
{
case SERPENT:
m_image=IMG_Load("Images/serpent.bmp");
break;
default :
break;
}
}

#ifndef DEF_GRAPHIQUE
#define DEF_GRAPHiQUE
#include <SDL/SDL.h>
#include "erreur.h"
#include "serpent.h"
#include "image.h"
class Graphique
{
public :
Graphique();
private :
SDL_Surface *m_ecran;
Erreur m_erreur;
Serpent m_serpent;
Image *m_imageSerpent;
void effacement();
void actualiser();
void afficherSerpent();
};
#endif

#include <SDL/SDL.h>
#include <string>
#include "image.h"
#include "constantes.h"
#include "erreur.h"
#include "graphique.h"
using namespace std;
Graphique::Graphique()
{
m_ecran=SDL_SetVideoMode(300, 300, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
if(m_ecran==NULL)
{
m_erreur.erreur(ECRAN);
}
m_imageSerpent.chargerImage(SERPENT);
}
void Graphique::effacement()
{
SDL_FillRect(m_ecran,NULL,SDL_MapRGB(m_ecran->format,0,0,0));
}
void Graphique::actualiser()
{
SDL_Flip(m_ecran);
}
void Graphique::afficherSerpent()
{
SDL_Rect position;
position.x=m_serpent.get_X();
position.y=m_serpent.get_Y();
}

Et voici ce que me dis mon compilo :

Citation : Mon compilo

graphique.cpp:19: error: `chargerImage' has not been declared
graphique.cpp:19: error: request for member of non-aggregate type before '(' token
:: === Génération finie: 2 erreurs, 0 avertissements ===

Je n'y comprend rien :euh:

PS: En regardant l'aperçus final des codes que je vien de donner, je vien de remarquer la coloration syntaxique des méthodes.
Comment faire en sorte que cela me fasse pareil sur code block ?
En gros j'aimerais que par exemple Classe::methode() methode soit en violet comme dans les codes qu'on peut voir dans ce forum.

Anonyme

19 août 2007 à 15:37:47

m_imageSerpent est un pointeur, tu dois donc mettre '->' et pas '.'

Pour la coloration, je ne sais pas.

rrazpo

19 août 2007 à 15:45:51

Citation : hiura

m_imageSerpent est un pointeur, tu dois donc mettre '->' et pas '.'

C'était stupide mais c'était bien ça

Bon, merci à tous pour votre aide. Je met en résolus (par contre j'aimerais tout de même savoir pour la coloration syntaxique :-°

Nanoc

19 août 2007 à 16:28:31

Pour la coloration syntaxique c'est dans les options de C::B

Settings -> Editor -> Syntax highlighting

Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.

rrazpo

19 août 2007 à 16:46:13

Hum...

Je vien de faire :

Parametres->editeur->coloration syntaxique

Mais il n'y pas de Syntax highlighting

Seulement : Matching brace hightlight et No matching brace hightlight

J'ai essayer de changer la couleur des deux mais aucun ne correspond

J'ai la version de code block traduite en français c'est peut être pour ça non ?

Nanoc

19 août 2007 à 17:04:54

tu as la RC2 ou une nighty builds ?

Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.

rrazpo

19 août 2007 à 17:25:38

Je n'en ai aucunes idées (Qu'est ce que RC2 ?).

Par contre, je l'ai trouvé sur le forum du site du zéro. Donc il doit être dans les pages du forum.

Il n'y à plus de fonction recherche donc je ne peut pas te fournir de lien désoler.

[Kansuu]

19 août 2007 à 18:00:55

Citation : rrazpo

Je n'en ai aucunes idées (Qu'est ce que RC2 ?).

Par contre, je l'ai trouvé sur le forum du site du zéro. Donc il doit être dans les pages du forum.

Il n'y à plus de fonction recherche donc je ne peut pas te fournir de lien désoler.

Cherche dans les tuto, y'en a un sur les nighty build.

Edit: Le voila.

rrazpo

19 août 2007 à 18:26:01

Je n'ai jamais installé de nighty builds, mais je ne sais pas si j'ai la RC2.

Anonyme

19 août 2007 à 18:34:39

Si tu n'as jamais installé de nightly builds et que tu as C::B en français, c'est presque certain que tu as la RC2.
Les nightly builds sont en fait des versions intermédiaires entre la RC2 et la RC3 qui devrait sortir... je sais pas trop quand.
L'avantage des nigthly builds est qu'elles sont mises à jour constamment (presque tous les jours, une nouvelle nigthly build sort). Le défaut, c'est qu'elles sont en anglais, mais bon on s'y fait vite et à la limite, c'est même mieux de s'habituer à l'anglais si tu veux programmer.

Pour la coloration syntaxique, il n'est malheureusement pas possible de colorer automatiquement les fonctions membres (je viens de vérifier).