Coucou, j´ai un gros pb et je ne sais pas pourquoi ca intervient. Les details :

class toto{
toto() {int b;} // constructeur
~toto(){int c;} // destructeur
int a;
}
/* Ce main fonctionne */
main1(){
toto *p = new toto;
delete p;
}

/* Celui la ne fonctionne pas */
main2(){
toto *p = new toto[1];
delete p; //<= ca plante ici.
}

Une classe bidon, mais 2 main différents. Le deuxieme ne fonctionne pas. Au moment du deletage, une fenetre s´ouvre pour dire qu´il y a un pb de memoire. Si vous supprimez le destructeur de la classe, le main2 fonctionne a nouveau.

Si vous avez une idée....

ps:compilateur Visual C 6
ps2:je vais tenter de surcharger l´operateur new de ma classe pour les tableaux...Je croise les doigts...

main2(){
toto *p = new toto[1];
delete p; //<= ca plante ici.
}

essayes cela:
main2(){
toto *p = new toto[1];
delete p[]; //<= ca plante ici.
}

Cela marche?

Yes Karine ca marche...

en fait j´avais trouvé la soluce un peu avant.

En surchargenant les operateur new, new[] et delete de ma classe, je me suis apercu que le pointeur passé a delete était différent de 4 octets de celui fournis a new. ( alors que le pointeur fournis a l´origine est bon).

enfin bon... maintenant g plus dde probleme de mémoire !

Merci Karine

toute maniere pour supprimer un tableau avec delete c´est pas delete tabo; kil fo faire mais delete [] tablo; plutot.

et au fait tes constructeurs et destructeurs sont inutiles mettre un int b; et puis fin de la fonc ca devrait meme faire un warning unused variable ou unreferenced etc...

Tu pourrais m´expliquer comment t´arrives a faire marcher ton programme?
Quand on fait une classe et qu´on precise rien, par defaut, tout est en private. Alors je suis curieux de savoir comment tu peux instancier des objets de ta classe avec un constructeur en private : ) J´pense que n´importe quel compilo digne de ce nom doit te jeter a ce stade la.

Enfin, soit tu as mal recopié, soit faudrait que tu bosses un peu plus le c++. Et jsuis pessimiste quant au fait que tu arrives a surcharger correctement les operateurs new et delete..

Kookii, je pense que Arnaud81 a simplifié le programme volontairement pour montrer l´essentiel de son bug.

Pour le constructeur private, ce n´est pas un problème regarde:

class KDino
{
private:
KDino(){};
public:
static KDino* AllocDino() { return new KDino(); }
};

void main()
{
KDino* pDino = KDino::AllocDino();
}

A quel niveau as tu un problème avec la surcharge de new/delete? j´ai pas trop compris. Peux-tu m´expliquer dans le détails?

Il a pas ecris ca dans son programme, il a essaye d appeler un constructeur prive.

Le constructeur est appele plein de fois par le compilo pr alleger l´ecriture sans que tu t´en rendes forcement compte.
Pour prendre un exemple, imagine dans ta class kdino t´as un constructeur

KDino(int);

ds ton prog si tu fais KDino Dino=2;
ca va marcher.

Alors faire comme tu fais c´est courir le risque qu´un jour un utilisateur appelle implicitement un constructeur.. Et y´a pas grand interet a passer par des methodes comme celles la. Sans compter qu´obliger l´utilisateur a passer par des fonction comme celle la, enleve de la simplicite. S´il fallait a chq fois qu´on voulait creer un objet aller voir quelle est la fonction qui remplace le constructeur ou le destructueur..

C´est pas la seule methode pour contourner les membres privees, y´a l´amitie...etc Mais bon, dans son programme y´avait rien de tout cela, enfin jpense que c´etait juste pour montrer que c´etait possible, j´espere pour toi que tu fais pas ca dans chacune de tes classes ; )

mais bien sur j´ai simplifié le truc !

j´allais pas vous mettre l´intégralité de mes class c tout, et j´ai utilisé ( presque) cet exemple pourvoir ou ca merdait.

En fait ca me dépasse que " new obj" et " new obj[x]" demande l´utilisation d´un delete différent ( delete et delete[]). surtout que quand on surcharge les operateurs new et de delete au niveau de la classe : on peut surcharger new plusieur fois, ce qui est pas possible avec delete ( possible 1 seule fois)

donc pour mes TESTS UNIQUEMENTS, j´ai surchargé l´opérateur new ( le simple, pas pour les tableaux)et delete.
en faisant un " new obj" et un " delete", tout marche parfaitement.
en faisant un " new obj[1 ou ce que tu veux]" et un " delete", l´allocation marche, mais l´adresse recu par la fonction surchargée delete est différente de +4 octets ( void* pointe sur del´octet ? ). donc en soustrayant 4 du pointeur recu par l´operateur delete, on peut supprimer un tableau avec delete ( surchargé parla classe) et non pas delete[]. Par contre, l´allocation simple " new obj" ne fonctionne plus.

Si vous avez pas compris ou si vous etes pas d´accord, c pasgrave, le pb est réglé. N´empeche...Pourquoi pour new char[10] un delete suffit mais pourun new obj[10] il faut delete[]...décidement...

ps: lightness, tu te rappel mon pb de lenteur sur mon editeur de nivo ? c´est réglé. un pb de pilote. et bien vu, bien que j´utilisais le mipmapping, ca ne se voyait pas a l´écran...et tu l´avaisbien vu. Maintenant, je vois la différence...

ps2:et oui kooki, j´y suis arrivé...Dommaaaaage ! !

ps3:je pensais que c t un bug du compilo car la version " Release" du programme ne pose pas de probleme, alors quela version " Debug" si...

" Il a pas ecris ca dans son programme, il a essaye d appeler un constructeur prive. "

Lol kookii ! !!

Je sais qu´il n´a pas ecrit ca dans son programme, je t´ai dit qu´il l´avait simplifier. Je t´ai donné mon exemple avec le constructeur privé suite a ce que tu disais a se sujet comme quoi ce n´etait pas possible, c´est tout.

" Le constructeur est appele plein de fois par le compilo pr alleger l´ecriture sans que tu t´en rendes forcement compte. "

Heureusement que je m´en rend compte sinon ca serait grave de coder des trucs sans savoir ce qu´il se passe...

" Alors faire comme tu fais c´est courir le risque qu´un jour un utilisateur appelle implicitement un constructeur.."

Bah non, y´a pas de risque, les mot clé private/protected/public sont là pour autorisé ou pas les accès, une classe bien implementée de posera aucun risque.

" Et y´a pas grand interet a passer par des methodes comme celles la"

C´était juste un exemple, perso je n´utilise pas cette méthode, par contre elle est ultra intensivement utilisée par microsoft dans les MFC.

" Sans compter qu´obliger l´utilisateur a passer par des fonction comme celle la, enleve de la simplicite."

Si on est ammené a le faire, c´est parce qu´il a vraiment nécessité. Peut etre que tu n´as fait que des programmes simple pour le moment et que tu n´as jamais recontré des problèmes à ce niveau, mais je te garanti que parfois on est obligé d´aller plus loin dans l´architecture de la simple classe CToto que l´on appris dans la 1ere page de la Bible C++.

Hs dino, faudrait que tu lises correctement la prochaine fois avant de repondre.

" Je t´ai donné mon exemple avec le constructeur privé suite a ce que tu disais a se sujet comme quoi ce n´etait pas possible, c´est tout. "
-->
J´ai dit qu´il n´etait pas possible qu´il instancie sa classe comme il l´a fait. J´ai jamais dit qu´on ne pouvait pas le faire.

" Alors faire comme tu fais c´est courir le risque qu´un jour un utilisateur appelle implicitement un constructeur.."
Je parle pas des mots cles je te parle qu´il se fera jeter par le compilateur. Si tu fais une lib en utilisant des procédés pareils, c´est courir le risque que l´utilisateur ne comprenne pas pk il peut pas utiliser la classe comme il le fait d´habitude.
Ensuite ta derniere ptite phrase sur les classes toto montre bien que toi tu n´y connais pas grand chose, a programmer tout seul dans ton coin sans te preoccuper des autres. Si un jour tu as des librairies a ecrire, tu comprendras surement. Enfin, je doute que tu aies lu la norme du c++ sinon tu raconterais pas autant de betises pour te rendre interessant.

Pour repondre a arnaud, c´est normal que qd tu fasses un tableau de char avec new, et qu´ensuite tu appelle le delete tout seul ca marche.
La difference entre delete et delete [] ( attention je parle pas de ceux que tu pourrais surcharger, mais des normaux), c´est que delete [] appelle le destructeur de chaque objet du tableau. Si cela peut marcher avec un delete normaux pour des chars, il ne faut quand meme pas melanger les 2 ( new [] et delete tout simple). Car il se peut que la memoire ne soit pas totalement liberee. Les standards precisent que melanger les 2 peuvent amener a des comportements variables. En gros ca depend du gars qui a fait le compilateur. Et tu auras pas forcement le meme resultats en utilisant 2 compilateurs differents. Si jamais tu es un peu curieux, essaye de faire des tests, pour voir si ta memoire est effectivement bien liberee correctement en allouant par ex des gros tableaux et en utilisant ensuite un debbuger qui detecte les fuites de memoire.

kookii

" Si cela peut marcher avec un delete normaux pour des chars, il ne faut quand meme pas melanger les 2 ( new [] et delete tout simple). Car il se peut que la memoire ne soit pas totalement liberee"

Ben oui elle sera pas totalement libérée, c´est sûr. Déjà si son tableau comporte plusieurs objets, le simple delete ne libèrera que le premier, les autes restant donc en mémoire. Et même s´il n´a alloué qu´un seul objet avec un new char[1] par ex., il restera toujours ces 4 octects dont a parlé arnaud qui sont en fait au choix(ça dépend du cas) la taille du tableau en octects ou alors le nombre d´objets.

" Les standards precisent que melanger les 2 peuvent amener a des comportements variables. En gros ca depend du gars qui a fait le compilateur."

Ok ça dépend du compilo mais y a pas des tonnes de solutions possibles. En fait y en a que 2, celle où les pointeurs passés aux 2 delete sont égaux(ex. gcc avec lequel le source d´arnaud compile très bien) et celle où ils sont différents de 4 octects(VC++ donc). J´ai déjà expliqué pour VC++mais donc pour gcc c´est pas trop compliqué non plus, les 4 octects sont ceux qui précèdent l´emplacement indiqué par le pointeur. En gros, pour retrouver la taille du tableau il suffira de faire *((int*)(int(lepointeur)-4))

Dernière précision: je crois pas qu´il soit nécessaire de " Ensuite ta derniere ptite phrase sur les classes toto montre bien que toi tu n´y connais pas grand chose, a programmer tout seul dans ton coin sans te preoccuper des autres. Si un jour tu as des librairies a ecrire, tu comprendras surement. Enfin, je doute que tu aies lu la norme du c++ sinon tu raconterais pas autant de betises pour te rendre interessant. " ou de " Enfin, soit tu as mal recopié, soit faudrait que tu bosses un peu plus le c++. Et jsuis pessimiste quant au fait que tu arrives a surcharger correctement les operateurs new et delete.. " , je ne suis pas sûr que cela représente tout à fait leur niveau

Un des interets possible de surcharger new/delete des classes seraient de faire un log des resources mémoires utilisés ( telle classe a tel adresse consume tant).

mmmmm, ca me donne des idées ca......

" Un des interets possible de surcharger new/delete des classes seraient de faire un log des resources mémoires utilisés ( telle classe a tel adresse consume tant).

mmmmm, ca me donne des idées ca......"

oh oh! welcome dans the monde of the programmation : )

huhu

" Ensuite ta derniere ptite phrase sur les classes toto montre bien que toi tu n´y connais pas grand chose, a programmer tout seul dans ton coin sans te preoccuper des autres. Si un jour tu as des librairies a ecrire, tu comprendras surement."

Je suis loin de tout connaitre et je n´ai pas la prétention de dire que je sais tout, j´essaye juste de discuter sur des choses que je connais. Pour ma part, je développe mon petit projet http://www.zythum.fr.st tout seul dans mon coin avec mes 25 librairies, mes 50 000 lignes de codes et mes 400 sources, le tout fonctionnement très bien jusqu´a présent. Lorsque j´ai travaillé comme codeur dans le jeu vidéo sur un MMORTS 3D l´architecture etait en C++ et je n´ai eu aucun problème a ce niveau.

" c´est courir le risque que l´utilisateur ne comprenne pas pk il peut pas utiliser la classe comme il le fait d´habitude"

Y´a pas " d´habitude" en prog, juste des mécanismes qui doivent fonctionner d´une facon logique. Je te le repete, ca marche comme ca avec les MFC.

" Enfin, je doute que tu aies lu la norme du c++ sinon tu raconterais pas autant de betises pour te rendre interessant."

Y´a pas de normae C++. Par contre il y a des normes comme la norme ANSI par exemple, mais bon c´est un peu obsolete, d´ailleur nos compilo n´applique meme pas cette norme. Donc disctuer c´est prog c´est ce rendre interessant? Pas pour moi en tout cas...

Bon, étant donné ta pretention et ton attitude quelque peu desagreable, je suppose que tu es en FAC/Ecole d´ingé d´info n´est ce pas?

Va donc faire un tour sur ce lien.. tu verras si il n´y a pas de norme c++.
http://www.ncits.org/standards/pr14882.htm
Je te laisse qd meme le bénéfice du doute... puisque j´appelle ca norme c++ et que tu as p-e mal compris. Sinon ca te montre qu´il existe bel et bien une norme. ( Comme tu parles de norme ANSI, comme si ANSI=norme du C++, j´ai de tres gros doutes puisque l´organisation ANSI normalise plusieurs choses). Quoiqu´il en soit, tu peux me repprocher d´avoir dit norme c++ puisque ce n´est pas reellement son vrai nom, mais je peux te repprocher de dire norme ansi egalement, et d´avoir dit qu´il n´existait pas de norme pour le c++.

Sinon ce qui m´embete un peu c´est que tu qualifies la norme d´obsolète. S´il n´y avait pas de normes, il n´y aurait pas d´informatique, alors médite un peu la dessus.

Pour les compilateurs qui respectent pas les normes, tu as deja entendu parler des parametres -ansi et -pedantic? La encore je te renvoie a la doc qui va avec.. Et tu verras qu´il est possible de respecter scrupuleusement la norme.

Pour finir, tu dis que je suis prétencieux, mais c´est toi qui vient parler et " etaler ta science" pour montrer qu´il est possible d´avoir des constructeurs privés et qui m´a dit que je n´etais jamais alle plus loin que la class toto du bouquin de c++.

lol, keep cool men !

Take that broom out of your ass

Les MFC sont peut etre pas un tres bon exemple lol... Car il faut comprendre comment marche l´intégralité du système pour les utiliser.

Et quand on regarde une source MFC, ce n´est plus de l´objet, c´est... du mystère car je me demande bien comment ca marche...En tout cas, je comprend la taille des progs générés avec ca : p.

Mais qu´est ce qu´on s´en tape de vos vies messieurs et des normes que vous respectez ou non, de voscompilateurs qui fonctionnenent plus ou moins.

En attendant koki, tu m´a jugé et condamné sans même me connaitre et sansmeme te poser des questions, et ca, il semblerait que ca a chatouillé plusieurs personnes. Alors tu t´emporte, mais regarde qui a commencéa etre incorrect.

ps:dino, j´ai vu les images ton moteur landscape et j´aimerais avoir qq truc pour obtenir la meme chose avec mon éditeur:p

FIN DE CE TOPIC. LE PROBLEME A ETE REGLE ! ! MERCI DE VOTRE PARTICIPATION !

vive les pointeurs auto ! ! ( ok jsuis HS)