Un pointeur qui disparait !

Question

Bonjour, J'ai un gros problème avec un pointeur ! Je devellope une fonction qui recherche un mot dans un texte afin de stocker l'indice de début et de celui-ci. Pour ce stockage j'utilise un pointeur a deux dimensions. Malheuresement, j'ai l'impression que ce pointeur s'efface une fois que je sors de la fonction ! Si vous pouviez regarder mon code s'il vous plait... Merci beaucoup #include #include #include int rechercher(int **selection,char *tab, int cpt_selection, char *mot, int mode,int *cpt) { int cpt2; int tai_mot=strlen(mot); while (tab[*cpt]!=0) { cpt2 = 0; if (tab[*cpt]==mot[cpt2]) { while ((tab[*cpt]==mot[cpt2])&&(cpt2<=tai_mot)) { (*cpt)++; cpt2++; } if (cpt2==tai_mot) //on a trouvé un mot. On sauvegarde donc l'indice du début et de fin de ce mot dans le tableau de selection { selection=(int **) realloc(selection , (cpt_selection+1) * sizeof(int *));//on alloue le nombre de ligne nécessaire *(selection+cpt_selection)=(int *) malloc(2 * sizeof(int)); //on alloue les deux cases selection[cpt_selection][0]=*cpt-tai_mot; selection[cpt_selection][1]=*cpt-1; cpt_selection++; } }else { (*cpt)++; } } printf(" debut : %ld ",selection[0][0]); printf("fin : %ld ",selection[0][1]); return cpt_selection; } int main() { char tab[300]={"C'est un point important ! point point "}; char mot[10]={"point"}; int **selection; int tai_util=strlen(tab); int cpt_selection=0, mode=0, cpt=0; selection=(int **) malloc(1 * sizeof(int *)); //on alloue de l'espace pour le tableau de selection puts(tab); printf(" "); printf("2 : rechercher tout"); fflush(stdin); scanf("%ld",&mode); if (mode==2) cpt_selection=rechercher(selection,tab,cpt_selection,mot,mode,&cpt); printf(" cpt selection : %ld ",cpt_selection); printf("debut après : %ld ",selection[0][0]); printf("fin après : %ld ",selection[0][1]); system("PAUSE"); return 0; }

NitRic · Answer

Exemple, tu vas tout comprendre(enfin, ca devrait :})

void func1( int i )
{
    i = 5;
}
int main()
{
  int i = 7;
  func1( i );

  printf("%d
", i); /* ca va afficher: 7 */

/*
pourquoi? parce seul la valeur
de `i` est envoy&#233;e &#224; la fonction func1()
il faudrait plut&#244;t lui envoyer son adresse(celle de `i`)
*/

  return 0;
}

void func2( int * i )
{
  (*i) = 5; /* il faut le d&#233;r&#233;f&#233;rencer */
/*
  (*i) == int i; du main()
  ta un acc&#232;s direct &#224; la variable(via son adresse)
*/
}
int main()
{
  int i = 7;
  func2( &i ); /* on envoi l'adresse de `i` */

  printf("%d
", i); /* ca va afficher: 5 */

  return 0;
}

avec ton code:

void ta_fonction( int *** selection, ... )
{

  int ** ptr;

  /* code ... */

  ptr = (int **) realloc( (*selection), nouvelle_taille ); /* m&#234;me chose ici, il faut d&#233;r&#233;f&#233;rencer */
  if ( NULL != ptr )
 {
    (*selection) = ptr;
  }
  else
  {
      !!!!ERROR!!!!
   }

  /* code ... */
}
int main()
{

  int ** selection;
  ta_fonction( &selection, ... ); /* on envoi l'adresse de `selection` */

  /* ... */

  return 0;

}

Voil&#224;, j'esp&#232;re que ce n'est pas trop vague comme explication :}

~(.:: NitRic ::.)~

NitRic · Answer

Au fait:

pointeur = realloc( pointeur, nouvelle_taille );

c'est mauvais ca, tr&#232;s mauvais, si realloc() &#233;choue
tu pers tout. exemple:

  char * string;
  string = malloc( 256 );

  strcpy( string, une_chaine_ici );
  string = realloc( string, 512 );

Si realloc() &#233;choue, string vaut NULL par la suite et donc
la m&#233;moire allou&#233;e via malloc() est perdu => fuite de m&#233;moire

donc, un pointeur suppl&#233;mentaire est, et de loin, pr&#233;f&#233;rable.

  char * string;
  char * pointer;

  string = malloc( 256 );

  strcpy( string, une_chaine_ici );
  pointer = realloc( string, 512 );

  if ( NULL != pointer )
    string = pointer;
  else
    puts("ERROR!!!");

Si realloc() &#233;choue, `pointer` vaut NULL mais `string` reste inchang&#233; donc
tu as toujours ton pointeur sur la m&#233;moire allou&#233;e

Au fait, pour ce qui est de l'acc&#232;s aux diff&#233;rents &#233;l&#233;ments de ton tableau `selection` dans
ta fonction, c'est simple:

void ta_fonction( int *** selection, ... )
{

  /* code, allocation, code, ... */
 (*selection)[x][y] = valeur;

 /* etc ... */

}

~(.:: NitRic ::.)~

benjiiim94 · Answer

Oki pour le realloc, je securiserai ca plus tard.



En ce qui concerne le passage du pointeur, si je peus me permettre tu as tort....

En effet, je vai pas t'aprendre que le pointeur est une adresse, donc en metant **selection, ca passe.

Le probl&#232;me n'est malheuresement pas ici. Je viens juste de
m'apercevoir qu'il fonctionne tr&#232;s bien avec le mode pas a pas de Dev
C++ ! C'est a ne rien n'y comprendre !



Merci de votre aide

NitRic · Answer

Fait un test tout b&#234;te:

void fonction( int ** tableau )
{
    tableau = (int **) malloc( 5 * sizeof(int *) );
    (*tableau) = malloc( 5 * sizeof(int) );


    (*tableau)[0] = 5;
    (*tableau)[1] = 17;
}
int main()
{
    int ** tableau;


    fonction( tableau );
    printf("%d - %d
", (*tableau)[0], (*tableau)[1]);

    free( *tableau );
    free( tableau );

    return 0;
}

Si tu as de la chance, ca va afficher du garbage, dans le cas contraire, ca va planter!
Ta fonction doit accepter un `int *** selection` et tu dois lui passer `&selection`

La variable elle-m&#234;me repr&#233;sente une adresse, pour pouvoir modifier directement `selection`, tu dois donner aux fonctions l'adresse de cette derni&#232;re. Le code, version fonctionnel, serait:

void fonction( int *** tableau )
{
    (*tableau) = (int **) malloc( 5 * sizeof(int *) );
    *(*tableau) = malloc( 5 * sizeof(int) );


    *(*tableau)[0] = 5;
    *(*tableau)[1] = 17;

    /*********************************************
     *
         *tableau pointe sur `selection` (dans le main())
         *(*tableau) pointe sur `*selection` ou si tu pr&#233;f&#232;re, sur `selection[0]`
         *(*tableau)[0] pointe sur `(*selection)[0]` ou encore: `selection[0][0]`

         Toi, dans ton code, lorsque tu `tente` de d&#233;r&#233;f&#233;rencer `selection`
         tu pointe sur: selection[0][0]

         type func( int ** selection, ... )
         {
            /* code ... */
            *(selection+cpt_selection)=(int *) malloc( ... );
            /* code ... */
         }

         Dans ce code, tu pointe tout simplement sur `selection[0][cpt_selection]`

         Va relire un peu sur les pointeurs, d&#233;r&#233;f&#233;rencements, allocations m&#233;moires,
         etc ... etc ...

         Dis toi que les variables que tes fonctions recoivent sont
         locals aux fonctions alors, pour pouvoir modifier une variable
         externe &#224; la fonction(re&#231;u en param&#232;tre), la fonction doit
         conna&#238;tre l'adresse de la variable &#224; modifier => son adresse !!!
         Alors donne lui l'adresse de la variable &#224; modifier!

         Si ca peu t'aider, regarde ceci:

         int ** selection;
         &selection == adresse de base(de la variable)
         * == pointeur qui pointe sur rien au d&#233;but
         * == autre pointeur qui pointe aussi sur rien

         en gros, ca donne ceci:
            & => * => adresse de `selection`
            *  => *
            *  => *
         Voil&#224; d'ou provient les trois ast&#233;rix
     *
     *********************************************/

}
int main()
{
    int ** tableau;


    fonction( &tableau );
    printf("%d - %d
", (*tableau)[0], (*tableau)[1]);

    free( *tableau );
    free( tableau );

    return 0;
}

D&#233;sol&#233; si mes explications ne sont pas parfaites, j'avous ne pas &#234;tre tr&#232;s dou&#233; dans ce domaine.

~(.:: NitRic ::.)~

NitRic · Answer

En parlant du mode pas-a-pas, c'est normal, comme j'ai dis plus haut, variable => local
alors c'est tout &#224; fait normal que les allocations m&#233;moire/manipulations/etc... n'&#233;choue pas, le contraire ne serait pas normal par contre.

~(.:: NitRic ::.)~

NitRic · Answer

Derni&#232;re petite chose, si dans ta fonction tu voudrais &#233;viter les: *(*(selection))[x] etc ... avoir quelque chose de plus ... `jolie/simple/...!?`, tu peux tr&#232;s bien faire par exemple:

type func( int *** selection, ... )
{

   int ** ptr = NULL;
   int ** sel = (*selection);

   /* ... */
   ptr = (int **) realloc( sel, ... );
   /* ... */
   sel[0] = (int *) malloc( ... );
   /* ... */

   (*selection) = sel; /* &#224; ne pas oublier */
   return value;
}

~(.:: NitRic ::.)~

NitRic · Answer

Les Pointeurs:
http://www.linux-kheops.com/doc/ansi-c/node35.htm#SECTION00500000000000000000

~(.:: NitRic ::.)~

Un pointeur qui disparait !

7 réponses

Votre réponse

Discussions similaires