Exemple de mon prog :
 
class alien {
 
} avec un constructeur
 
class alien_pool
{
        alien *pool = new alien[200];
}
 
Marche po ... Dans le main oui, mais pas dans la classe alien pool ... Comment je fais alors ??

[edtdd]--Message édité par bfg--[/edtdd]

on fait pas d'alloc dans une classe. dans une fonctions de la classe oui

Okey !! Donc je déclare ma variable, et je l'instancie et l'initialise dans un constructeur par exemple ?

par ex
oublie pas de l'instancier  

Merci !! Ca marche !! Enfin, à la compilation ! Ca fait 3 ans que j'ai plus fait de C ... Et la j'attaque direct le C++ ... Chaud !
 
Encore merci !  

Si tu utilises la méthode de TheJackal n'oublies pas de faire un delete dans le descruteur.
 
Sinon tu peux faire ça et la dectruction est automatique:
 
 
class alien {  
 
};  
 
class alien_pool  
{  
       alien pool[200];  
};

de rien. tu vera le c++ est super
qu'est ce ke t'appelle instancier au faite  ?

 
c vrai aussi

TheJackal a écrit a écrit : de rien. tu vera le c++ est super qu'est ce ke t'appelle instancier au faite  ?

 
Ou là, je me mélange les pinceaux avec les termes ... Ben pour moi instancier c'est par exemple :
 
void main()
{
alien_pool p = new alien_pool;
}
 
ce qui après merde quand je fais :
 
p.create_alien(); ... Pace que Mosieur veut un pointeur ... J'y perd mon latin, j'en avais fais en cous ya quelques année, ça m'avais parru plus simple ...

Voici mon code de test :
 
#include "allegro.h"
 
#define VIVANT 1
#define MORT 0
#define TIR 2
#define EXPLOSION 3
#define FAUX 0
#define VRAI 1
 
class alien {
public :
 
  int etat;     // VIVANT,EXPLOSION,MORT,TIR
  int pos_x;     //
  int pos_y;     // Position x et y sur l'écran
  int cadence_tir;   // Vitesse de tir
  int cadence_tir_compteur; // Décompte pour le prochain tir
  int type_tir;    // Type du tir
  int taille_x;    //
  int taille_y;    // Taille en largeur(x), hauteur(y)
  int zone_de_touche_x1;  //
  int zone_de_touche_x2;  //
  int zone_de_touche_y1;  //
  int zone_de_touche_y2;  // Zone de collision avec un objet
  int weak_point_x1;   //
  int weak_point_x2;   //
  int weak_point_y1;   //
  int weak_point_y2;   // Zone de collision point faible avec un objet
  int animation_normale[50]; // Tableau d'animation pour mouvement classique
  int animation_attaque[50]; // Tableau d'animation lorsque tir
  int animation_explosion[50];// Tableau d'animation lorsque explosion
  int pv;      // Point de vie
  int mouvement;    // Type de mouvement
 
  void init(int vpos_x,int vpos_y,int vcadence_tir,int vtype_tir,int vpv,int vmouvement);
         // Initialise l'alien avec les données en paramètre
  void set_zone_de_touche(int x1,int y1,int x2,int y2);
         // Initialise la zone de touche
  void set_weak_point(int x1,int y1,int x2,int y2);
         // Initialise le point faible
  void set_animation_normale(int index,int valeur);
         // Initialise une image de l'animation normale
  void set_animation_attaque(int index,int valeur);
         // Initialise une image de l'animation attaque
  void set_animation_explosion(int index,int valeur);
         // Initialise une image de l'animation explosion
  void shoot();    // Fait tirer l'alien
  void hit();     // Enlève un point de vie OU fait exploser l'alien
  void die();     // Fait mourir l'alien
  void move();    // Bouge l'alien selon le mouvement/etat ...
  int iscollide_zone_de_touche(int sx1,int sy1,int sx2,int sy2);
         // Est-il en collision (par rapport aux paramêtres)
  int iscollide_weak_point(int sx1,int sy1,int sx2,int sy2);
         // Est-il en collision (par rapport aux paramêtres)
  void update();    // Gère la vie de l'alien avec les méthodes du dessus
  alien() { etat=MORT;}; // Constructeur
};
 
 void alien::init(int vpos_x,int vpos_y,int vcadence_tir,int vtype_tir,int vpv,int vmouvement) {
   pos_x = vpos_x;
   pos_y = vpos_y;
   cadence_tir = vcadence_tir;
   cadence_tir_compteur = cadence_tir;
   type_tir = vtype_tir;
   pv = vpv;
   mouvement = vmouvement;
 };
 
 void alien::set_zone_de_touche(int x1,int y1,int x2,int y2) {
  zone_de_touche_x1 = x1;
  zone_de_touche_y1 = y1;
  zone_de_touche_x2 = x2;
  zone_de_touche_y2 = y2;
 };
 
 void alien::set_weak_point(int x1,int y1,int x2,int y2) {
  weak_point_x1 = x1;
  weak_point_y1 = y1;
  weak_point_x2 = x2;
  weak_point_y2 = y2;
 };
 
 void alien::set_animation_normale(int index,int valeur){
  animation_normale[index] = valeur;
 };
 
 void alien::set_animation_attaque(int index,int valeur){
  animation_attaque[index] = valeur;
 };
 
 void alien::set_animation_explosion(int index,int valeur){
  animation_explosion[index] = valeur;
 };
 
 void alien::shoot(){
  etat = TIR;
 };
 
 void alien::hit(){
  pv--;
  if (pv<=0)
   etat = EXPLOSION;
 };
 
 void alien::die(){
  etat = MORT;
 };
 
 void alien::move(){
  if (mouvement==0)
   pos_x--; // Mouvement simple de base
 };
 
 int alien::iscollide_zone_de_touche(int sx1,int sy1,int sx2,int sy2){
  return FAUX;
 };
 
 int alien::iscollide_weak_point(int sx1,int sy1,int sx2,int sy2){
  return FAUX;
 };
 
 void alien::update(){
  if (etat==TIR) etat=VIVANT;
   
  if (etat==VIVANT) {
 
   cadence_tir_compteur--;
   
   if (cadence_tir_compteur<=0) {
    shoot();
    cadence_tir_compteur = cadence_tir;
   }
 
   move();  
  }
 };
 
 
 class alien_pool {
 public:
  alien pool[200];  
 
  void create_alien();
  int etat_alien(int nalien);
 };
 
 void alien_pool::create_alien(){
  pool[0].etat = VIVANT;
 };
 
 int alien_pool::etat_alien(int nalien){
  return pool[nalien].etat;
 }
 
int main()
{
 alien_pool p = new alien_pool;
 
 p.create_alien();
 
   /* you should always do this at the start of Allegro programs */
   allegro_init();
 
   /* set up the keyboard handler */
   install_keyboard();  
 
   /* set a graphics mode sized 320x200 */
   if (set_gfx_mode(GFX_DIRECTX_WIN, 640, 480, 0, 0) != 0) {
      set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
      allegro_message("Unable to set any graphic mode\n%s\n", allegro_error);
      return 1;
   }
 
   /* set the color palette */
   set_palette(desktop_palette);
 
   /* clear the screen to white */
   clear_to_color(screen, makecol(255, 255, 255));
 
   /* you don't need to do this, but on some platforms (eg. Windows) things
    * will be drawn more quickly if you always acquire the screen before
    * trying to draw onto it.
    */
   acquire_screen();
 
   /* set transparent text */
   text_mode(-1);
 
   /* write some text to the screen with black letters */
   if (p.etat_alien(0)==VIVANT)  
 textout_centre(screen, font, "VIVANT", SCREEN_W/2, SCREEN_H/2, makecol(0,0,0));
   
   if (p.etat_alien(0)==MORT)  
 textout_centre(screen, font, "MORT", SCREEN_W/2, SCREEN_H/2, makecol(0,0,0));
 
   /* you must always release bitmaps before calling any input functions */
   release_screen();
 
   /* wait for a keypress */
   readkey();
 
   return 0;
}
 
END_OF_MAIN();
 
Il merde ...
Vous pourriez me diriger un peu pour que je prenne des bonnes bases ...

alien_pool *p = new alien_pool;  
 
p->create_alien();  
 
new aloue de la mem pour un pointeur et non une var normal

Purée !! Qu'est ce que je suis con !!
 
Je faisais p--> au lieu de p-> !!
 
raaaa !! Bon ça devrait aller !!
 
ENCORE MERCI BEAUCOUP POUR TOUT !!
 
A si, dernière question mon alien pool[200]; la mémoire est alloué ??

?
la meme mem est toujours aloc
seulement comme ta fait l'alloc / desalloc se fait tout seul
ya ke new qui doit etre suivit de delete

Okey ! Bon, ça marche ! Je continue le dev, les choses se remettent en place dans ma ch'tite caboche !!
 
MERCI !
 
 

jsuis curieux mais tu fait koi? et avec koi?

 
Alors, je tente le développement d'un shoot'em up à scrolling horizontal avec MS VC++ et allegro (utilisant Direct X) ...
 
Pour l'instant, je cherche des structures de données cohérentes, et me remémore mon C++  ...    

bonne chance et surtout n'hesite pas a revenir si ta un blem

Okey ! Thxs !