Instanciation dangereuse ?

Bonjour,

Pour les besoins d'une application je suis confronté à un problème quelque peu tordu
J'ai 2 classes, classeA et classeB.
J'aimerais pouvoir créer (de façon dynamique) un objet de type classeA via un pointeur membre de classeB.
hum, bon ok   voici un petit exemple:

dans main.h :

class classeA
{
  public:
    int entierA; 
    void creerObjet(classeA **p);
    void libererMem(classeA **p); 
};  

class classeB
{ 
  public:
     classeA *m_pClasseA;  //Pointeur membre sur classeA
};

dans main.cpp :

void classeA::creerObjet(classeA **p)
{
   *p = new classeA; //alloue de la mémoire pour un nouvel objet
   return;
}

void classeA::libererMem(classeA **p)
{
   delete *p; //Libère la mémoire alloué
   return;
}

int main(int argc, char *argv[])
{
  classeB *pCB = new classeB;//Créé un objet classeB via un pointeur
 
  pCB->m_pClasseA = 0;//initialise les membres
  pCB->entierB = 0;

  pCB->m_pClasseA->creerObjet(&(pCB->m_pClasseA));
  pCB->m_pClasseA->entierA = 56;// On peut maintenant accéder aux membres 
                                                         // du nouvel objet de type classeA via un 
                                                          // pointeur sur un objet de type classeB
 
  pCB->m_pClasseA->libererMem(&(pCB->m_pClasseA));
  delete pCB;
 
  system("PAUSE"); 
  return 0;
}

Apparement ce petit programme fonctionne mais, n'étant pas un guru du c++ j'aimerais
savoir si cet exemple est correcte et si je peux m'en servir dans un programme plus conséquent  sans courir de risques ?

D'avance merci

Tintin 72

hello

plusieurs points:
préfère des membres privés,
met à null les pointeurs inutilisés,
fait des controles.


repris, ton code donnerai:

class CA
{
private:
    int m_iA;
public:
  CA(){m_iA=0;}
  CA(const int val){m_iA=val;}
  ~CA(){}
   int get()const {return m_iA;}
   void set(const int iA){m_iA=iA;}
};  

class CB
{ 
private:
     classeA *m_pCA;  //Pointeur membre sur classeA
  public:
     CB()m_p(NULL){}
    ~CB(){destroy();}
     create(){destroy();m_pCA=new CA();}
     create(const int val){destroy();m_pCA=new CA(val);}
     destroy(){if(m_pCA)delete(m_pCA);}
   int get()const {if(m_pCA)return m_pCA->get();else return 0;}
   void set(const int iA){if(m_pCA) m_pCA->set(iA);}
};

int main(int argc, char *argv[])
{
  CB *pCB = new CB;//Créé un objet classeB via un pointeur
  pCB->set( 0);//échec

  pCB->create();
  pCB->set(56);// On peut maintenant accéder aux membres 
                                                         // du nouvel objet de type classeA via un 
  ...                     
  pCB->destroy();
  delete( pCB);
 
  system("PAUSE"); 
  return 0;
}

enfin, ce n'est que ce que j'aurai fait;
à vous la team
___________________________________________________________
Magicalement
Nono

classeA à remplacer par CA , ds la def de CB, oki

et le pCB->destroy();
est optionnel