[C] plantage a la liberation de la memoire

plantage a la liberation de la memoire [C] - C - Programmation

Marsh Posté le 10-08-2004 à 20:16:26    

Bonjour, ou plutot bonsoir,
 
Voila je bosse sur cette liste chainée depuis ce matin, tout marche bien sauf la fonction SLfree qui a une tendance a planter... Donc si quelqu'un voit pourquoi...
Je pense que ca peut etre quelque chose que j'ai pas fais de maniere assez "propre" mais je vois pas pourquoi les plantages sont pas tout le temps au meme endroit dans la fonction.
Donc bon je pourrais ne pas liberer la memoire en fin de programme mais c'est loin d'etre une maniere elegante de faire je trouves...
 

Code :
  1. //constantes
  2. #define SL_FLOAT 1
  3. #define SL_DOUBLE 2
  4. #define SL_INT 3
  5. #define SL_CHAR 4
  6. #define SL_STRING 5
  7. #define SL_LONG 6
  9. #define SL_CHAR_FLOAT "float"
  10. #define SL_CHAR_DOUBLE "double"
  11. #define SL_CHAR_INT "int"
  12. #define SL_CHAR_CHAR "char"
  13. #define SL_CHAR_STRING "string"
  14. #define SL_CHAR_LONG "long"
  17. //error codes
  18. #define SL_OK 0x00
  19. #define SL_Error 0x01
  20. #define SL_ERROR_FILE_EXIST 0x10
  21. #define SL_ERROR_READ 0x11
  22. #define SL_ERROR_WRITE 0x12
  23. #define SL_ERROR_OPEN_FILE 0x13
  24. #define SL_ERROR_FILE_NOT_OPENED 0x14
  25. #define SL_ERROR_UNKNOWN_DATA 0x15
  26. #define SL_ERROR_VAR_NOT_FOUND 0x16
  28. typedef struct _SLelement
  29. {
  30. int iSLtype;
  31. char *sVarName;
  32. void *pvVal;
  33.     struct    _SLelement *NextElm;
  34.     struct    _SLelement *PrevElm;
  36. }SLelement,*pSLelement;
  38. typedef class SLfile
  39. {
  40. private :
  41. pSLelement pSLfirst,pSLlast,pSLcurrent;
  42. FILE *file;
  43. public :
  44. int SLfile::SLinit(); //ok
  45. int putVar(char *cVarName,int iVarType,void *pvValue);
  46. int addVar(pSLelement); //ok
  47. int delVar(char *cVarName); //ok
  48. int changeValue(char *VarName,int iVarType, void *pvVal); //ok
  49. int scanValue(char *cVarName,int iVarType); //ok
  50. pSLelement findVar(char *cVarName); //ok
  51. int writeVar(pSLelement); //ok
  52. int printVar(char *cVarName); //ok
  53. int printAllVar(); //ok
  54. int readVar(char *cVarName,void *pvValue);
  55. int readFile(); //ok
  56. int writeFile(); //ok
  57.     int SLfree(); //ok
  58. int SLfopen(char *filename,char *mode); //ok
  59. int SLfclose(); //ok
  60. }sSLfile,*psSLfile;
  62. int SLfile::SLinit()
  63. {
  65. SLfile::pSLfirst=(pSLelement)0;
  66. SLfile::pSLlast=(pSLelement)0;
  67. SLfile::pSLcurrent=(pSLelement)0;
  68. SLfile::file=(FILE *)0;
  69. return SL_OK;
  70. }
  72. int SLfile::SLfree()
  73. {
  74. pSLelement pslCur;
  76. pslCur=SLfile::pSLlast->PrevElm;
  77. while (pslCur!=(pSLelement)0)
  78. {
  79.  free(pslCur->NextElm->sVarName);
  80.  free(pslCur->NextElm->pvVal);
  81.  free(pslCur->NextElm);
  82.  pslCur->NextElm=(pSLelement)0;
  83.  pslCur=pslCur->PrevElm;
  84. }
  85. /*free(SLfile::pSLfirst->sVarName);
  86. free(SLfile::pSLfirst->pvVal);
  87. free(SLfile::pSLfirst);
  88. SLfile::pSLfirst=(pSLelement)0;
  89. SLfile::pSLlast=(pSLelement)0;*/
  90. return SL_OK;
  91. }
  93. int SLfile::SLfclose()
  94. {
  95. fclose(SLfile::file);
  96. return SL_OK;
  97. }
  99. int SLfile::SLfopen(char *filename,char *mode)
  100. {
  102. SLfile::file=fopen(filename,mode);
  104. if (SLfile::file==(FILE *)0)
  105.  return SL_ERROR_OPEN_FILE;
  107. return SL_OK;
  108. }
  110. int SLfile::addVar(pSLelement SLe)
  111. {
  112. pSLelement pSLnew;
  114.  pSLnew=(pSLelement)malloc(sizeof(SLelement));
  115.  pSLnew->iSLtype=SLe->iSLtype;
  116.  pSLnew->sVarName=(char *)malloc((strlen(SLe->sVarName)+1)*sizeof(char));
  117.  strcpy(pSLnew->sVarName,SLe->sVarName);
  118.  pSLnew->pvVal=(void *)malloc(sizeof(int *));
  119.  switch(SLe->iSLtype)
  120.  {
  121.  case SL_INT : *(int *)pSLnew->pvVal  = *(int *)SLe->pvVal;
  122.  break;
  123.  case SL_LONG : *(long *)pSLnew->pvVal  = *(long *)SLe->pvVal;
  124.  break;
  125.  case SL_DOUBLE: *(double *)pSLnew->pvVal = *(double *)SLe->pvVal;
  126.  break;
  127.  case SL_FLOAT: *(float *)pSLnew->pvVal  = *(float *)SLe->pvVal;
  128.  break;
  129.  case SL_CHAR: *(char *)pSLnew->pvVal  = *(char *)SLe->pvVal;
  130.  break;
  131.  case SL_STRING: sprintf((char *)pSLnew->pvVal,"%s",(char *)SLe->pvVal);
  132.  break;
  133.  }
  135. if (SLfile::pSLcurrent==(pSLelement)0) //first element
  136. {
  137.  SLfile::pSLcurrent=pSLnew;
  138.  SLfile::pSLcurrent->NextElm=(pSLelement)0;
  139.  SLfile::pSLcurrent->PrevElm=(pSLelement)0;
  140.  SLfile::pSLfirst=SLfile::pSLcurrent;
  141.  SLfile::pSLlast=SLfile::pSLcurrent;
  142. }
  143. else
  144. {
  145.  pSLnew->PrevElm=SLfile::pSLcurrent;
  146.  pSLnew->NextElm=SLfile::pSLcurrent->NextElm;
  147.  SLfile::pSLcurrent=pSLnew;
  148.  SLfile::pSLlast->NextElm=SLfile::pSLcurrent;
  149.  SLfile::pSLcurrent->PrevElm=SLfile::pSLlast;
  150.  SLfile::pSLlast=SLfile::pSLcurrent;
  151. }
  153. return SL_OK;
  154. }
  156. int SLfile::putVar(char *cVarName,int iVarType,void *pvValue)
  157. {
  158. SLelement sle;
  160. sle.sVarName=(char *)malloc((strlen(cVarName)+1)*sizeof(char));
  161. strcpy(sle.sVarName,cVarName);
  162. sle.iSLtype=iVarType;
  163. sle.pvVal=(void *)malloc(sizeof(int *));
  165. switch(sle.iSLtype)
  166. {
  167.  case SL_INT : *(int *)sle.pvVal  = *(int *)pvValue;
  168.  break;
  169.  case SL_LONG : *(long *)sle.pvVal  = *(long *)pvValue;
  170.  break;
  171.  case SL_DOUBLE: *(double *)sle.pvVal = *(double *)pvValue;
  172.  break;
  173.  case SL_FLOAT: *(float *)sle.pvVal  = *(float *)pvValue;
  174.  break;
  175.  case SL_CHAR: *(char *)sle.pvVal  = *(char *)pvValue;
  176.  break;
  177.  case SL_STRING: sprintf((char *)sle.pvVal,"%s",(char *)pvValue);
  178.  break;
  179. }
  181. SLfile::addVar(&sle);
  182. return SL_OK;
  183. }
  185. int SLfile::writeVar(pSLelement sle)
  186. {
  187. int iRes;
  189. if (SLfile::file==(FILE *)0)
  190.  return SL_ERROR_FILE_NOT_OPENED;
  192. switch(sle->iSLtype)
  193. {
  194. case SL_INT : iRes=fprintf(SLfile::file,"int\t%s = %d;\n",sle->sVarName,*(int *)sle->pvVal);
  195.  break;
  196. case SL_LONG : iRes=fprintf(SLfile::file,"long\t%s = %ld;\n",sle->sVarName,*(long *)sle->pvVal);
  197.  break;
  198. case SL_DOUBLE:iRes=fprintf(SLfile::file,"double\t%s = %lf;\n",sle->sVarName,*(double *)sle->pvVal);
  199.  break;
  200. case SL_FLOAT:iRes=fprintf(SLfile::file,"float\t%s = %f;\n",sle->sVarName,*(float *)sle->pvVal);
  201.  break;
  202. case SL_CHAR:iRes=fprintf(SLfile::file,"char\t%s = %c;\n",sle->sVarName,*(char *)sle->pvVal);
  203.  break;
  204. case SL_STRING:iRes=fprintf(SLfile::file,"string\t%s = %s;\n",sle->sVarName,(char *)sle->pvVal);
  205.  break;
  206. }
  208. if (iRes<0)
  209.  return SL_ERROR_WRITE;
  210. return SL_OK;
  211. }
  213. int SLfile::writeFile()
  214. {
  215. pSLelement pslCur;
  218. pslCur=SLfile::pSLfirst;
  219. while (pslCur!=(pSLelement)0)
  220. {
  221.  SLfile::writeVar(pslCur);
  222.  pslCur=pslCur->NextElm;
  224. }
  226. return SL_OK;
  227. }
  229. int SLfile::readFile()
  230. {
  231. char buffer[1024];
  232. char buf[1024];
  233. int i,iPos,iPos2;
  234. SLelement sle;
  236. for (i=0;i<1024;i++)
  237. {
  238.  buf[i]='\0';
  239.  buffer[i]='\0';
  240. }
  242. while(!feof(file))
  243. {
  244.  fscanf(SLfile::file,"%s",buffer);
  246.  //type of var
  247.  if (strncmp(buffer,SL_CHAR_INT,sizeof(SL_CHAR_INT))==0) {sle.iSLtype=SL_INT;}
  248.  else if (strncmp(buffer,SL_CHAR_DOUBLE,sizeof(SL_CHAR_DOUBLE))==0){sle.iSLtype=SL_DOUBLE;}
  249.  else if (strncmp(buffer,SL_CHAR_FLOAT,sizeof(SL_CHAR_FLOAT))==0){sle.iSLtype=SL_FLOAT;}
  250.  else if (strncmp(buffer,SL_CHAR_LONG,sizeof(SL_CHAR_LONG))==0){sle.iSLtype=SL_LONG;}
  251.  else if (strncmp(buffer,SL_CHAR_CHAR,sizeof(SL_CHAR_CHAR))==0){sle.iSLtype=SL_CHAR;}
  252.  else if (strncmp(buffer,SL_CHAR_STRING,sizeof(SL_CHAR_STRING))==0){sle.iSLtype=SL_STRING;}
  253.  else
  254.  {
  255.   return SL_ERROR_UNKNOWN_DATA;
  256.  }
  259.  //var name
  260.  fscanf(SLfile::file,"%s = ",buffer);
  261.  sle.sVarName=(char *)malloc((strlen(buffer)+1)*sizeof(char));
  262.  strcpy(sle.sVarName,buffer);
  263.  sle.pvVal=(void *)malloc(sizeof(int *));
  265.  //value
  266.  switch(sle.iSLtype)
  267.  {
  268.   case SL_INT : fscanf(SLfile::file,"%d;\n",(int *)sle.pvVal);
  269.   break;
  270.   case SL_LONG : fscanf(SLfile::file,"%ld;\n",(long *)sle.pvVal);
  271.   break;
  272.   case SL_DOUBLE:fscanf(SLfile::file,"%lf;\n",(double *)sle.pvVal);
  273.   break;
  274.   case SL_FLOAT:fscanf(SLfile::file,"%f;\n",(float *)sle.pvVal);
  275.   break;
  276.   case SL_CHAR:fscanf(SLfile::file,"%c;\n",(char *)sle.pvVal);
  277.   break;
  278.   case SL_STRING:fscanf(SLfile::file,"%s;\n",(char *)sle.pvVal);
  279.   break;
  280.  }
  281.  SLfile::addVar(&sle);
  283. }
  285. return SL_OK;
  286. }
  288. pSLelement SLfile::findVar(char *cVarName)
  289. {
  291. pSLelement pslCurrent;
  294. pslCurrent=SLfile::pSLfirst;
  295. while ((pslCurrent!=(pSLelement)0)&&(strncmp(pslCurrent->sVarName,cVarName,strlen(cVarName))))
  296. {
  297.  pslCurrent=pslCurrent->NextElm;
  298. }
  301. return pslCurrent;
  302. }
  304. int SLfile::scanValue(char *cVarName,int iVarType)
  305. {
  306. pSLelement pslCurrent;
  307. SLelement sle;
  309. pslCurrent=SLfile::findVar(cVarName);
  311. if (pslCurrent==(pSLelement)0)
  312. {
  313.  sle.iSLtype=iVarType;
  314.  sle.pvVal=(void *)0;
  315.  sprintf(sle.sVarName,"%s",cVarName);
  316.  SLfile::addVar(&sle);
  317.  pslCurrent=SLfile::findVar(cVarName);
  318. }
  321. printf("%s = ",pslCurrent->sVarName);
  322. switch(pslCurrent->iSLtype)
  323. {
  325.  case SL_INT : scanf("%d;\n",(int *)pslCurrent->pvVal);
  326.  break;
  327.  case SL_LONG : scanf("%ld;\n",(long *)pslCurrent->pvVal);
  328.  break;
  329.  case SL_DOUBLE:scanf("%lf;\n",(double *)pslCurrent->pvVal);
  330.  break;
  331.  case SL_FLOAT:scanf("%f;\n",(float *)pslCurrent->pvVal);
  332.  break;
  333.  case SL_CHAR:scanf("%c;\n",(char *)pslCurrent->pvVal);
  334.  break;
  335.  case SL_STRING:scanf("%s;\n",(char *)pslCurrent->pvVal);
  336.  break;
  337. }
  339. SLfile::changeValue(cVarName,pslCurrent->iSLtype,pslCurrent->pvVal);
  341. return SL_OK;
  342. }
  344. int SLfile::printVar(char *cVarName)
  345. {
  346. pSLelement pslCurrent;
  349. pslCurrent=SLfile::findVar(cVarName);
  351. if (pslCurrent==(pSLelement)0)
  352. {
  353.  return SL_ERROR_VAR_NOT_FOUND;
  354. }
  356. switch(pslCurrent->iSLtype)
  357. {
  358.  case SL_INT : printf("%s = %d\n",cVarName,*(int *)pslCurrent->pvVal);
  359.  break;
  360.  case SL_LONG : printf("%s = %ld\n",cVarName,*(long *)pslCurrent->pvVal);
  361.  break;
  362.  case SL_DOUBLE:printf("%s = %lf\n",cVarName,*(double *)pslCurrent->pvVal);
  363.  break;
  364.  case SL_FLOAT:printf("%s = %f\n",cVarName,*(float *)pslCurrent->pvVal);
  365.  break;
  366.  case SL_CHAR:printf("%s = %c\n",cVarName,*(char *)pslCurrent->pvVal);
  367.  break;
  368.  case SL_STRING:printf("%s = %s\n",cVarName,(char *)pslCurrent->pvVal);
  369.  break;
  370. }
  372. return SL_OK;
  373. }
  375. int SLfile::printAllVar()
  376. {
  377. pSLelement pslCurrent;
  379. pslCurrent=SLfile::pSLfirst;
  380. while (pslCurrent!=(pSLelement)0)
  381. {
  382.  SLfile::printVar(pslCurrent->sVarName);
  383.  pslCurrent=pslCurrent->NextElm;
  384. }
  386. return SL_OK;
  387. }
  389. int SLfile::delVar(char *cVarName)
  390. {
  391. pSLelement pslCur;
  393. pslCur=SLfile::findVar(cVarName);
  395. if (pslCur==(pSLelement)0)
  396. {
  397.  return SL_ERROR_VAR_NOT_FOUND;
  398. }
  400. pslCur->PrevElm->NextElm=pslCur->NextElm;
  401. pslCur->NextElm->PrevElm=pslCur->PrevElm;
  402. free(pslCur);
  404. return SL_OK;
  405. }
  407. int SLfile::changeValue(char *cVarName,int iVarType,void *pvVal)
  408. {
  409. pSLelement pslCur;
  411. pslCur=SLfile::findVar(cVarName);
  413. if (pslCur==(pSLelement)0)
  414. {
  415.  return SL_ERROR_VAR_NOT_FOUND;
  416. }
  418. pslCur->iSLtype=iVarType;
  419. pslCur->pvVal=pvVal;
  421. return SL_OK;
  422. }
  424. int SLfile::readVar(char *cVarName,void *pvValue)
  425. {
  426. pSLelement pslCur;
  428. pslCur=SLfile::findVar(cVarName);
  430. if (pslCur==(pSLelement)0)
  431. {
  432.  return SL_ERROR_VAR_NOT_FOUND;
  433. }
  435. switch(pslCur->iSLtype)
  436. {
  437.  case SL_INT : *(int *)pvValue  = *(int *)pslCur->pvVal;
  438.  break;
  439.  case SL_LONG : *(long *)pvValue = *(long *)pslCur->pvVal;
  440.  break;
  441.  case SL_DOUBLE: *(double *)pvValue = *(double *)pslCur->pvVal;
  442.  break;
  443.  case SL_FLOAT: *(float *)pvValue = *(float *)pslCur->pvVal;
  444.  break;
  445.  case SL_CHAR: *(char *)pvValue = *(char *)pslCur->pvVal;
  446.  break;
  447.  case SL_STRING: sprintf((char *)pvValue,"%s",(char *)pslCur->pvVal);
  448.  break;
  449. }
  450. return SL_OK;
  451. }


Message édité par GuiYom_00 le 10-08-2004 à 20:29:33
Reply

Marsh Posté le 10-08-2004 à 20:16:26   

Reply

Marsh Posté le 10-08-2004 à 20:22:07    

oh du C :o

Reply

Marsh Posté le 10-08-2004 à 20:25:07    

et alors?

Reply

Marsh Posté le 10-08-2004 à 20:25:35    

ben te la joue pas C++ alors :o

Reply

Marsh Posté le 10-08-2004 à 20:30:00    

Voila j'ai rectifié le titre...

Reply

Marsh Posté le 10-08-2004 à 20:33:42    

ce que t'es idiot ...

Reply

Marsh Posté le 10-08-2004 à 21:47:29    

bon, que je m'explique alors vu que on dirait que quelqu'un ici aime a ce que l'on soit precis...
Oui j'ai fais une classe C++, et oui j'utilise les fonctions C malloc, printf... et autres et non je ne veux pas changer pour iostream.h et new, delete a la place de malloc free...
Et bon, que je sache, ca m'etonnerait que les problemes viennent de l'utilisation de malloc a la place de new vu que dans mon cas, j'ai vérifié et je n'ai pas de problemes lors des allocations...

Reply

Marsh Posté le 10-08-2004 à 21:56:19    

ton problème c'est que tu fais du très mauvais C avec des classes C++ :  à mélanger les genre, tu n'as que les inconvénients des 2 langages
 
 
edit : y a pas a dire, je ne garderais pas une seule ligne, ton C est vraiment mauvais  et dangereux. revois tes bases sur les FILE* (feof en particulier), (f)scanf, découvre fgets, les enums, les déclarations imbriquées, le mot clef const, vire tes cast inutiles. tes allocations sont bugguées et défaillantes, tu passes ton temps à corrompre ta mémoire. y a pas un seul malloc correct
 
quant au C++, n'en parlons pas


Message édité par Taz le 10-08-2004 à 22:05:42
Reply

Marsh Posté le 10-08-2004 à 22:08:56    

GuiYom_00 a écrit :

Oui j'ai fais une classe C++, et oui j'utilise les fonctions C malloc, printf... et autres


ouais enfin a la base tu choisis entre C et C++ et tu t'y tiens, à part quand t'as pas le choix tu code pas dans un truc hybride avec des bouts de C et des bouts de C++...

Citation :

et non je ne veux pas changer pour iostream.h


et <iostream>?
 
Après pour la technique 'pure' je ne vais sûrement pas prétendre être du niveau du grincheux croulant ( :whistle: ) donc je vais te laisser voir ce qu'il dit


---------------
Stick a parrot in a Call of Duty lobby, and you're gonna get a racist parrot. — Cody
Reply

Marsh Posté le 10-08-2004 à 22:23:55    

en fait ce qui se passe c que j'ai un code fait a 95% en C et pour me faciliter la vie, j'aurais juste besoin de la classe C++ que j'ai copié au dessus...  
donc voila pourquoi je veux pas tout reprendre maintenant que j'en suis a un peu plus de 5000 ligne de code quand meme...

Reply

Marsh Posté le 10-08-2004 à 22:23:55   

Reply

Marsh Posté le 10-08-2004 à 22:41:52    

ben quand t'es pas capable de faire un malloc correct mais que tu te permets de critiquer new, j'ai peur ...

Reply

Marsh Posté le 10-08-2004 à 22:51:16    

alors dans ce cas dis moi ou mon malloc est pas correct...
si c'est a cause des typecast, c juste pour que VS gueule pas...

Reply

Marsh Posté le 10-08-2004 à 23:01:38    

 sle.pvVal=(void *)malloc(sizeof(int *));  dans readFile par exemple :o

Reply

Marsh Posté le 10-08-2004 à 23:05:15    

tu preferes que je mettes   sle.pvVal=(void *)malloc(sizeof(void *));
mais bon ca ne changes quand meme rien...

Reply

Marsh Posté le 10-08-2004 à 23:07:37    

tes classes ne sont meme pas canonique

Reply

Marsh Posté le 10-08-2004 à 23:08:08    

le problème c'est pas ça :o

Reply

Marsh Posté le 10-08-2004 à 23:09:49    

oui je sais

Reply

Marsh Posté le 10-08-2004 à 23:10:38    

GuiYom_00 a écrit :

tu preferes que je mettes   sle.pvVal=(void *)malloc(sizeof(void *));
mais bon ca ne changes quand meme rien...


 
c'est un pointeur sur quel type sle.pvVal ?

Reply

Marsh Posté le 10-08-2004 à 23:16:12    

justement, ca depends... ca peut etre float, int, double...
donc par defaut je mets un void et apres je fais un cast quand je veux lui donner une valeur particuliere... mais bon, vu que tout les pointeurs ont la meme taille, c'est vrai que c'est pas la dessus que j'ai porté toute mon attention...
 
Edit : c'est vrai que une fois que je serais sur que les fontions marchent, je m'occuperai de rendre la classe canonique...


Message édité par GuiYom_00 le 10-08-2004 à 23:20:13
Reply

Marsh Posté le 10-08-2004 à 23:19:48    

si tu veux allouer pour un double
sle.pvVal=malloc(sizeof(double));  
...
 
le cast du malloc est inutile

Reply

Marsh Posté le 10-08-2004 à 23:20:15    

oui mais ce que tu fous dedans :o

Reply

Marsh Posté le 10-08-2004 à 23:21:56    

dans quoi ?

Reply

Marsh Posté le 10-08-2004 à 23:23:13    

*(double *)pSLnew->pvVal = *(double *)SLe->pvVal
 
 
et après ça y va ....

Reply

Marsh Posté le 10-08-2004 à 23:25:19    

ouai :D

Reply

Marsh Posté le 10-08-2004 à 23:26:09    

et je parle pas du cast de lvalue qui est rigoureusement interdit :o

Reply

Marsh Posté le 10-08-2004 à 23:29:49    

et yen a partout

Reply

Marsh Posté le 10-08-2004 à 23:31:22    

sprintf((char *)pSLnew->pvVal,"%s",(char *)SLe->pvVal);  
 
et ça c'est pas beau ?

Reply

Marsh Posté le 10-08-2004 à 23:31:40    

ok si je veux allouer pour un double je fais sle.pvVal=malloc(sizeof(double));
mais le truc c'est que je ne sais pas a l'avance quel est le type des variables or dans ma declaration il faut quand meme que je dise que j'ai besoin d'un pointeur...
 
Peut etre que si j'explique un peu plus dans quel but je fais cette classe, cela rendra les choses plus claires...
Un programme a besoin de X parametres , par exemple un temps (double), une position (aussi double), le nom d'un fichier (char *)...et il faut qu'il stocke ces parametres dans un fichier a qu'il puisse les relire a chaque execution...
Dans ce cas, je me sers de cette classe pour creer le fichier avec les valeurs dedans, et aussi pour le lire...
Donc vu que mes variables peuvent etre de differents type, je ne vois pas comment faire autrement que par des void * et des cast...

Reply

Marsh Posté le 10-08-2004 à 23:33:21    

« il faut quand meme que je dise que j'ai besoin d'un pointeur... » le fait est que tu n'as pas besoin d'un pointeur
 
 
la solution classique C, c'est union + enum, comme j'ai déjà maintes fois donné l'exemple

Reply

Marsh Posté le 10-08-2004 à 23:33:46    

c'est stylisé

Reply

Marsh Posté le 10-08-2004 à 23:35:12    

c'est canonique comme façon de faire

Reply

Marsh Posté le 10-08-2004 à 23:50:33    

Oui c'est vrai que j'avais pas pensé au systeme enum+union...
mais ca n'empeche que j'aimerais savoir pourquoi j'ai les free qui plantent de temps en temps alors que, meme si l'utilisation des void * n'est peut etre pas la plus "jolie", a aucun moment dans les test que j'ai fais je n'ai eu de problemes pour lire mes valeurs, les ecrire, les afficher ou quoi que ce sois d'autres...

Reply

Marsh Posté le 10-08-2004 à 23:51:31    

qu'est-ce que tu veux que tes free comprennent si tu cases tes données n'importe ou ? le problème c'est pas les free bordel :o

Reply

Marsh Posté le 10-08-2004 à 23:56:31    

mes mes données sont bien casées dans mes pointeurs void pourtant... donc je vois pas en quoi les free sont génés...
 
Edit  et pour en revenir aux expressions du type : *(int *)sle.pvVal  = *(int *)pvValue
Si j'ai fais ca, c'est que je ne veux pas que au moment ou je libere la memoire allouée a sle.pvVal, ca joue sur la zone memoire de pvValue...
Or si j'avais fais sle.pvVal=pvValue
et qu'ensuite je fais un free(sle.pvVal) alors que va-t-il advenir de la valeur de pvValue??


Message édité par GuiYom_00 le 10-08-2004 à 23:59:39
Reply

Marsh Posté le 10-08-2004 à 23:56:57    

NON :o

Reply

Marsh Posté le 11-08-2004 à 00:00:14    

alors elles sont ou mes données???

Reply

Marsh Posté le 11-08-2004 à 00:01:09    

la ou elle devrait pas être, ça corrompt tout et n'importe quoi

Reply

Marsh Posté le 11-08-2004 à 00:09:15    

ok donc dans ce cas je vais voir ce que me donne un petit debug en suivant bien tout du debut a la fin concernant la memoire pour savoir ou c que ca commence a partir en live...

Reply

Marsh Posté le 11-08-2004 à 00:10:31    

des que tu touches à un pointeur :o
 
tu gagnerais du temps à passer au modèle enum+union, plus d'allocation dynamique si ce n'est pour ta structure de données.
 
ou alors tu fais ça en 2 lignes de C++ avec std::list, mais c'est toi qui voit

Reply

Marsh Posté le 11-08-2004 à 00:15:42    

C'est sur que la liste chainée, je vois pas trop comment je pourrais faire autrement...
et bon, le modele enum+union est assez rapide a mettre en place, mais vu que je suis quand meme un peutetu, je vais essayer de voir plus en detail les raisons des plantages...car les pointeurs, je fais gaffe justement a essayer de pas trop les "deplacer" mais juste a modifier leurs valeurs...

Reply

Marsh Posté le    

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed