J´ai posté cette question dans le topic J´aide les personne en C/C++ mais il semble que j´ai été oublié . Alors je la reposte ici :

Bonjour à tous, j´ai un petit problème avec l´allocation dynamique d´un objet et je ne vois pas où trouver la théorie à ce sujet.

Supposons que je désire faire le tableau d´un objet, est-il acceptable de faire ( par exemple -- en supposant que xxx est un entier):

struct maStructure
{
int maVariable;

maStructure();
~maStructure();
} *tabStructure;

maStructure::maStructure()
{
maVariable = 0;
}

maStructure::~maStructure()
{
}

int main()
{
tabStructure = NULL;
/ / Plein d´autres opérations ici
tabStructure = new maStructure[xxx];
}

---------

Car, dans le cas du programme sur lequel je travaillais ( avant d´être un peu trop brusquemment intérompu par ce problème), j´ai une structure de ce genre ( qui est allouée dynamiquement) et qui contient deux char * ( eux aussi alloués dynamiquement). Or, dans mon destructeur, je fais un delete[] pour chacun des deux char *. Le résultat est, évidemment, un plantage . Des suggestions ?

Merci !

jaimelespates > Moi aussi j´aime les pates... Mais si on sait pas, pas la peine de poster !

Bon, je vien de recuperer ton code, et de tester avec des char* : sa marche bien

1. include < iostream>

struct maStructure
{
char* blabla1;
char* blabla2;

maStructure();
~maStructure();

void initBlabla1(char* string);
} *tabStructure;

maStructure::maStructure()
{
blabla1 = NULL;
blabla2 = NULL;
}

maStructure::~maStructure()
{
if(blabla1)
delete [] blabla1;
if(blabla2)
delete [] blabla2;
}

void maStructure::initBlabla1(char* string)
{
if(blabla1)
delete [] blabla1;
blabla1 = new char [strlen(string)+1];
strcpy(blabla1,string);
}

int main()
{
tabStructure = NULL;
// Plein d´autres opérations ici
tabStructure = new maStructure[12];

tabStructure[2].initBlabla1("Hello world");

// blablabla
delete [] tabStructure;
}

To plantage devait avoir lieu quand tu deletait tes char* : si tu ne les a pas créé, ils pointent n´importe ou dans la memoire et forcement si tu lui fait deleter la ou t´a pas le droit, il plante. C´est pourquoi je te conseil fortement d´initaliser tes pointeurs à NULL quand ils pointent vers rien.

Sinon, questions personels :
Pourquoi utiliser struc plutot que class? juste pour les membres public par defaut?
Bizard la fasson dont tu declare tabStructure, au dirait que ta struct n´est faite que pour etre manipulé par une seul instance.
Pourquoi si superman est super inteligent, il met son slip par dessus son pantalon ?

Voila, vé dormir maintenant

il est vrai que tu manipules tes struct comme des classes publiques...

je te conseille également de passer en classes :

class maClasse
{
private:
int maVariable;
public:
void methode1();
maClasse();
~maClasse();
};

Ensuite, tu peux en créer dynamiquement ainsi :

maClasse* tabclasse=new maClasse[10];

( il faut savoir qu´implicitement, le constructeur par défaut ( celui avec les ( ) ) sera appelé.

tabclasse[2]->methode1();

delete [] tabclasse;

Je ne sais pas si je réponds bien a ta question...