équivalent REALLOC en C++ !!!

bjr tt le monde,

je m'aitrise pas encore C++ et j'ai un pb !  pouvez vous m'aider à gangner du temps ;

// je cré au départ un tableau de pointeur sur une classe "Panne" (da taille = nbrPanne)
  Panne **P = new Panne*[nbrPanne];
  for(int i=0; i<nbrPanne; i++)   // pour chaque case
     P[i] = new Panne(nbrTotEtats);    // je cré les objets proprement dit
.......

typeP = ..........;      // je le récupère mais pb :  typeP peux être sup à "nbrPanne"

//je dois donc augmenter la taille du tableau pour pouvoir écrir : P[typeP-1]  !
// donc moi avant avec le "C" j'utilisais realloc pour réallouer un tableau
// mais là avec new j'ai pas trouvé !!!

P[typeP-1]->EtatPanne[P[typeP-1]->index++] = id;
      // juste pour info :  là j'enregistre les états de panne dans le tableau
      // "EtatPanne" de l'objet P[typeP-1]
      //  "index++" ; c pour connaitre après le nbre d'états de panne pour chaque objet P

.................


class Panne
{

public :    
   long nbrEtats; 
   long type, index; 
   long *EtatPanne; 

   Panne(long n); // Constructeur avec n : nbrEtats
   ~Panne();  // Déstructeur
};

Panne::Panne(long n)
{
    index = 0;
    nbrEtats = n;
    EtatPanne = new long[nbrEtats];
    for(int i=0; i<nbrEtats; i++)
       EtatPanne[i] = 0;
}
Panne::~Panne()
{
    if(EtatPanne)
      delete EtatPanne;
}

C'est trés simple, il suffit d'utiliser le template std::vector.

#include <vector>

std::vector<Panne> P(nbrPanne, Panne(nbrTotEtats));

Ne fait jamais de tableau de pointeurs (ou collection de pointeurs en générale) si ce n'est pas dans le but de tirer profit du polymorphisme.

Il manque aussi dans ta classe un constructeur par copie et un opérateur d'affecation que tu dois obligatoirement redéfinir si tu a besoin de redéfinir le desctructeur, ou au moins rendre ta classe non copiable.

dacord, mais vous avez pas un bon site pour comprendre la classe "Vector" !

donc
std::vector<Panne> P(nbrPanne, Panne(nbrTotEtats));  
 //   => là on crée un  vector avec "nbrPanne"  Panne 
 //                                                        initialisés avec "Panne(nbrTotEtats)"

et après on peux changer nbrPanne  pour augmenter la taille  ?!

et pour modifier les paramètres d'un objet, on utilise push_back  ?!

par exp :   P[typeP-1]->EtatPanne[P[typeP-1]->index++] = id;
ça devient :  
                        .....  ?!!!

je sais c laborieux  !

push_back ajoute un élément à la fin du tableau, dans ton cas ce n'est pas à utiliser je pense.

Pour changer la taille du tableau, dirige toi vers la fonction "resize" de vector.

Et je pense que tu peut utiliser realloc dans ton programme C++ (#include <cstdlib>).

---

Sachant qu'on peut toujours enlever une ligne à un programme, et que dans un programme il y a toujours un bug, un programme peut se résumer à une ligne avec un bug.

c ça , moi je veux rajouter au fur et à mesure les éléments (je l'ai pas noté mais typeP  s'incrémente par pas de 1 );

donc pour augmenter le vector d'1 élément ;
   P.push_back( Panne(nbrTotEtats) );

et pour écrir, ça reste :
   P[typeP-1]->EtatPanne[P[typeP-1]->index++] = id;

c ça non ?!

Surtout pas, il ne faut jamais utilliser les allocateurs du C en C++ sauf si on sait ce que l'on fait. Ca ne construit rien et ca ne détruit rien. Pour un tableau de type non POD il faudrait quand meme faire des placements new et des appels explicites de destructeur, ca n'a aucun sens.

Oui c'est ca, tu l'utilises comme un tableau.

P[typeP-1]->EtatPanne[P[typeP-1]->index++] = id;

En POO ce n'est pas trés prope, pour respecter l'encapsulation ca devrait etre

P[typeP-1]->setEtatPanne(id);

On a pas à savoir que la classe Panne à un membre EtatPanne qui est un tableau et un membre index.