Instanciation dangereuse ?

Question

Bonjour,


Pour les besoins d'une application je suis confront&#233; &#224; un probl&#232;me quelque peu tordu 
J'ai 2 classes, classeA et classeB. 
J'aimerais pouvoir cr&#233;er (de fa&#231;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&#233;moire pour un nouvel objet
   return; 
}


void classeA::libererMem(classeA **p)
{
   delete *p; //Lib&#232;re la m&#233;moire allou&#233;
   return; 
}



int main(int argc, char *argv[])
{
  classeB *pCB = new classeB;//Cr&#233;&#233; 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&#233;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'&#233;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&#233;quent  sans courir de risques ? 


D'avance merci

Tintin 72

magic_Nono · Answer

hello



plusieurs points:

pr&#233;f&#232;re des membres priv&#233;s,

met &#224; null les pointeurs inutilis&#233;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&#233;&#233; un objet classeB via un pointeur
   pCB->set( 0);//&#233;chec


 
  pCB->create();

  pCB->set(56);// On peut maintenant acc&#233;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;

&#224; vous la team
___________________________________________________________
Magicalement
Nono

magic_Nono · Answer

classeA &#224; remplacer par CA , ds la def de CB, oki



et le  pCB->destroy();

est optionnel

Instanciation dangereuse ?

2 réponses

Votre réponse

Discussions similaires