Bonjour à tous,
Quand je crée un tableau de classes de manière "dynamique", de la façon suivante :
tab_classes = (Classe *)malloc(nombre*sizeof(Classe)), il me semble que le compilateur fait appel à un constructeur par défaut sans paramètres.
Or, si ensuite dans le code, pour chaque élément du tableau ainsi créé, j´utilise cette fois-ci un constructeur que j´ai écrit, par exemple :
for(i=0;i<nombre;i++) tab_classes[i] = Classe(param1,param2); est ce que c´est un nouvel objet qui est créé ou alors le précédent est remplacé ? A savoir est ce que cela occasionne des pertes de mémoire ?
Merci

quand tu fais:
tab_classes = (Classe *)malloc(nombre*sizeof(Classe))
AUCUN constructeur n´est appelé!! l´espace mémoire esst alloué et sa valeur n´est pas défini.

il faut faire tab_classes=new Classe[nombre] pour que les cstr par defaut soit utilisé.

Quand tu fais:
for(i=0;i<nombre;i++) tab_classes[i] = Classe(param1,param2);
la, tu commence par appeler le constructeur de Classe avec deux parametres, l´objet construit est passé en paramètre a l´opérateur d´affectation de Classe (le premier paramètre étant tab_classes[i])
finalement, l´objet anonyme est détruit a l´aide de son destructeur.

donc cette manière de procéder n´est pas adaptée à un travail optimisé ?

(Si non) Il aurait peut-etre fallu utiliser une méthode "update" qui modifie ta classe sans la re-créer

Ce qui n´est pas adapté c´est surtout d´utilisé malloc avec des classe.

Des que tu manipule des notions du C++ (enfin, quand tu utilise des classes) il faut utiliser new et delete pour être sûr que les constructeur et destructeur sont appellé (sinon, il ne le sont pas de toute manière).

hmm malloc (ou new char[]) + placements new est une technique tres utile dans certains cas (particules,etc), surtout lorsqu on veut eviter la fragmentation.

Pour revenir a la question de depart, tu peux tjs faire un new Classe[nombre], puis un for sur lequel tu appelle init(param1,param2).

D´accord merci

ça me rappelle une fois, un collegue avait décidé de mettre une std::map dans une structure.

struct truc
{
...
std::map M;
};

Il me disait (car j´ai été nommé spécialiste des STL a la boite : la classe)

"Mais !! ! map ça ne marche pas !! ! ça plante !! "
On regarde, on regarde, encore et encore : on elague le code, on fait des tests...

Un moment, j´ai fini par trouver :
Il avait malloqué la structure !! ! (c´est joli malloquer non ?)
Du coup, le constructeur de map n´avait pas été appelé, du coup : PAN !! !

On est resté une bonne heure a chercher quand meme !! (et lui davantage, car il avait commencé avant moi de chercher)

Monstrueux

--> des que ça cause de classes, oublier malloc : toujours new ! (ça instancie récursivement tous les membres d´une structure)