Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1507 connectés 

  FORUM HardWare.fr
  Programmation
  C

  [C] plantage a la liberation de la memoire

 
 


 Mot :   Pseudo :  
 
 Page :   1  2
Page Suivante
Page Précédente
Bas de page 
Auteur Sujet :

[C] plantage a la liberation de la memoire

n°819547
GuiYom_00
Posté le 10-08-2004 à 20:16:26  profilanswer
 

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
mood
Publicité
Posté le 10-08-2004 à 20:16:26  profilanswer
 

n°819552
Taz
bisounours-codeur
Posté le 10-08-2004 à 20:22:07  profilanswer
 

oh du C :o

n°819558
GuiYom_00
Posté le 10-08-2004 à 20:25:07  profilanswer
 

et alors?

n°819560
Taz
bisounours-codeur
Posté le 10-08-2004 à 20:25:35  profilanswer
 

ben te la joue pas C++ alors :o

n°819569
GuiYom_00
Posté le 10-08-2004 à 20:30:00  profilanswer
 

Voila j'ai rectifié le titre...

n°819571
Taz
bisounours-codeur
Posté le 10-08-2004 à 20:33:42  profilanswer
 

ce que t'es idiot ...

n°819602
GuiYom_00
Posté le 10-08-2004 à 21:47:29  profilanswer
 

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...

n°819607
Taz
bisounours-codeur
Posté le 10-08-2004 à 21:56:19  profilanswer
 

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
n°819615
masklinn
í dag viðrar vel til loftárása
Posté le 10-08-2004 à 22:08:56  profilanswer
 

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
n°819625
GuiYom_00
Posté le 10-08-2004 à 22:23:55  profilanswer
 

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...

mood
Publicité
Posté le 10-08-2004 à 22:23:55  profilanswer
 

n°819630
Taz
bisounours-codeur
Posté le 10-08-2004 à 22:41:52  profilanswer
 

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

n°819643
GuiYom_00
Posté le 10-08-2004 à 22:51:16  profilanswer
 

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...

n°819658
Taz
bisounours-codeur
Posté le 10-08-2004 à 23:01:38  profilanswer
 

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

n°819673
GuiYom_00
Posté le 10-08-2004 à 23:05:15  profilanswer
 

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

n°819683
cris56
Posté le 10-08-2004 à 23:07:37  profilanswer
 

tes classes ne sont meme pas canonique

n°819687
Taz
bisounours-codeur
Posté le 10-08-2004 à 23:08:08  profilanswer
 

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

n°819697
cris56
Posté le 10-08-2004 à 23:09:49  profilanswer
 

oui je sais

n°819701
cris56
Posté le 10-08-2004 à 23:10:38  profilanswer
 

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 ?

n°819732
GuiYom_00
Posté le 10-08-2004 à 23:16:12  profilanswer
 

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
n°819740
cris56
Posté le 10-08-2004 à 23:19:48  profilanswer
 

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

n°819741
Taz
bisounours-codeur
Posté le 10-08-2004 à 23:20:15  profilanswer
 

oui mais ce que tu fous dedans :o

n°819744
cris56
Posté le 10-08-2004 à 23:21:56  profilanswer
 

dans quoi ?

n°819747
Taz
bisounours-codeur
Posté le 10-08-2004 à 23:23:13  profilanswer
 

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

n°819749
cris56
Posté le 10-08-2004 à 23:25:19  profilanswer
 

ouai :D

n°819750
Taz
bisounours-codeur
Posté le 10-08-2004 à 23:26:09  profilanswer
 

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

n°819758
cris56
Posté le 10-08-2004 à 23:29:49  profilanswer
 

et yen a partout

n°819761
Taz
bisounours-codeur
Posté le 10-08-2004 à 23:31:22  profilanswer
 

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

n°819763
GuiYom_00
Posté le 10-08-2004 à 23:31:40  profilanswer
 

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...

n°819770
Taz
bisounours-codeur
Posté le 10-08-2004 à 23:33:21  profilanswer
 

« 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

n°819772
cris56
Posté le 10-08-2004 à 23:33:46  profilanswer
 

c'est stylisé

n°819775
Taz
bisounours-codeur
Posté le 10-08-2004 à 23:35:12  profilanswer
 

c'est canonique comme façon de faire

n°819809
GuiYom_00
Posté le 10-08-2004 à 23:50:33  profilanswer
 

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...

n°819813
Taz
bisounours-codeur
Posté le 10-08-2004 à 23:51:31  profilanswer
 

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

n°819819
GuiYom_00
Posté le 10-08-2004 à 23:56:31  profilanswer
 

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
n°819821
Taz
bisounours-codeur
Posté le 10-08-2004 à 23:56:57  profilanswer
 

NON :o

n°819827
GuiYom_00
Posté le 11-08-2004 à 00:00:14  profilanswer
 

alors elles sont ou mes données???

n°819829
Taz
bisounours-codeur
Posté le 11-08-2004 à 00:01:09  profilanswer
 

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

n°819837
GuiYom_00
Posté le 11-08-2004 à 00:09:15  profilanswer
 

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...

n°819840
Taz
bisounours-codeur
Posté le 11-08-2004 à 00:10:31  profilanswer
 

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

n°819850
GuiYom_00
Posté le 11-08-2004 à 00:15:42  profilanswer
 

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...

mood
Publicité
Posté le   profilanswer
 

 Page :   1  2
Page Suivante
Page Précédente
Haut de page 

Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  [C] plantage a la liberation de la memoire

 

Sujets relatifs
[debutant] Probleme d'allocation memoire pour de grands tableaux[Java] Problème de taille mémoire avec un JTree
[C++] Plantage d'une dll [résolu][ASM] Optim : précalcul en mémoire ou calcul sur registres ?
[Oracle] Debug - Forcer le plantage dans cas particulier...Mise en mémoire d'évènements midi : HashMap ?
pile memoire - modification donneesPlantage inexpliqué dès que je touche à un .h
[Weblogic] pas assez de mémoire sous l'EDI Workshopgestion de la memoire
Plus de sujets relatifs à : [C] plantage a la liberation de la memoire

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.228 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR