Discussion :

[oranoutan]

Bonjour,

Je souhaiterai savoir si l'affectation est bien comme ceci (pour tabA[0]), car quand je libère à la fin, j'ai une erreur de segmentation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
size_t l;
  // pas de control sur malloc() et de free() pour l'exemple
  char **tabA = malloc(3 * sizeof *tabA);
  for (l = 0; l < 3; l++)
      tabA[l] = malloc (10+1 * sizeof *tabA[l]);
 
  tabA[0] = "Bonjour";
  printf("\ntabA[0] -> %s", tabA[0]); // Bonjour

[Trap D]

Lorsque tu fais tabA[0] = "bonjour", tu affectes à tabA[0] une adresse en mémoire statique (et au passage tu as une fuite mémoire puisque l'ancienne adresse n'est pas libérée), ce qui fait que ça plante au moment de la libération.
Il faut faire strcpy(tabA[0], "bonjour"), pour que ça fonctionne correctement.

[oranoutan]

je ne comprend plus rien du tout,
quand on fait ça:

char *p;
on peut écrire :
p = "bonjour";
et
printf("%s", p);
alors pkoi on peut pas faire la même chose avec tabA

[Plancioni]

je ne comprend plus rien du tout,
quand on fait ça:

char *p;
on peut écrire :
p = "bonjour";
et
printf("%s", p);
alors pkoi on peut pas faire la même chose avec tabA

Ceci n'est valable qu'en debut de code.
tu ne peu pas faire sa au milieu de ton code tu sera donc obliger d'inserer manuellement tes caracteres. C'est a dire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
p[0] = 'b'
...
P[8] = '\0' // a ne pas oublier

[Trap D]

Ton problème vient de la libération mémoire lorsque tu fais le free.
Tu ne peux pas libérer de la mémoire qui n'a pas été allouée par un malloc/realloc.
Comme je l'ai dit précédemment, tu alloues bien de la mémoire par le malloc, ce que tu dois savoir c'est que le malloc renvoie une adresse valide je ne sais plus où exactement en mémoire.
Ensuite, lorsque tu fais tabA[0] = "bonjour", ce qui se passe c'est que le compilo te file une adresse dans une autre zone de la mémoire où est écrite en dur la chaîne "bonjour", donc ce faisant, tu perds l'ancienne adresse fournie par le malloc (cette zone ne pourra plus être libérée par un free) et la nouvelle adresse n'est plus libérable par un free.

[Emmanuel Delahaye]

Ceci n'est valable qu'en debut de code.
tu ne peu pas faire sa au milieu de ton code tu sera donc obliger d'inserer manuellement tes caracteres.

Mais qu'est-ce que tu racontes... On peut mettre l'adresse d'une chaine dans un pointeur quand on veux...

[Emmanuel Delahaye]

je ne comprend plus rien du tout,
quand on fait ça:

char *p;
on peut écrire :
p = "bonjour";
et
printf("%s", p);
alors pkoi on peut pas faire la même chose avec tabA

On pourrait si on était sûr de n'avoir à faire qu'à des chaines littérales (car ce sont des tableaux de char non modifiables et permanents.

Il suffirait alors de définir un simple tableau de pointeurs sur char.

[oranoutan]

Est t-il possible d'avoir un tableau dynamique de chaines à 1 dimension ?

[Emmanuel Delahaye]

Est t-il possible d'avoir un tableau dynamique de chaines à 1 dimension ?

C'est pas hyper clair comme question, mais à priori, on peut créer dynamiquement tout ce qu'on veut... Le principe, c'est :

Tableau de n T :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   T *p = malloc (sizeof *p * n);

Ce qui se décline en :

Tableau de n char :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   char *p = malloc (sizeof *p * n);

Tableau de n char* :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   char **p = malloc (sizeof *p * n);

etc.

[oranoutan]

Bonjour,

merci pour les réponses, oui ce n'est pas très clair comme question , je me mélange pas mal, faut dire.

quand on écrit,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

char *c[3] = {"Hello", " ", "world"};

c'est bien un tableau de chaine statique en 1 dimension ? ma question était de savoir si on pouvait faire la même chose en donnant une taille dynamiquement ?

Tableau de n T :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   T *p = malloc (sizeof *p * n);

Qu'es ce que le type T ?

[Emmanuel Delahaye]

quand on écrit,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

char *c[3] = {"Hello", " ", "world"};

c'est bien un tableau de chaine statique en 1 dimension ?

C'est un tableau de pointeurs sur char à une dimension initialisé avec l'adresses de chaines littérales (donc non modifiables). Je recommande d'ailleurs de définir ce tableau ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

char const *c[] = {"Hello", " ", "world"};

Nota : il n'est pas indispensable d'indiquer la taille, à moins qu'on veuille une taille plus grande que le nombre d'initialisateurs explicites (les autres sont alors de valeur 0, soit, ici, NULL).

ma question était de savoir si on pouvait faire la même chose en donnant une taille dynamiquement ?

Oui, bien sûr. J'ai donné le code. Ensuite, il faut initialiser les pointeurs. Attention, si on définit un tableau dynamique de char *; il ne faut pas donner l'adresse de chaines littérales, car non modifiables, mais donner l'adresse d'une copie de celle-ci en mémoire. strdup() facilite cette tâche (POSIX.1, donc très portable).

Si on tient aux chaines littérales, je recommande de définir un tableau de char const *.

Qu'es ce que le type T ?

N'importe quel type (sauf void). C'est une 'généralisation'. Tu n'as jamais fait ça en math ?

Ma réponse est assez 'dense'. N'hésite pas à poser des questions.

[oranoutan]

quand on fait ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
char *c[] = {"Hello", " ", "world"};
 
c[0] = c[2]; // pointe vers @ de c[2]
 
c[0] = malloc (7+1 * sizeof *c[0]);
strcpy (c[0], "bonjour");
printf ("%s", c[0]);

c[0] pointe sur l'adresse de c[2] dont l'espace mem contient la chaîne "world".
Que devient la chaîne "world" après strcpy(), on ne peut la modifier en principe puisque c'est une chaîne litérale, alors comment ça se passe ?
Quand on alloue une taille sur la zone de c[0] es-ce que "world" est détruit ?

[Emmanuel Delahaye]

quand on fait ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
char *c[] = {"Hello", " ", "world"};
 
c[0] = c[2]; // pointe vers @ de c[2]
 
c[0] = malloc (7+1 * sizeof *c[0]);
strcpy (c[0], "bonjour");
printf ("%s", c[0]);

Bien que ce soit techniquement possible, il faut être assez tordu pour mélanger dans le même tableau les pointeurs sur chaines littérales et les pointeurs sur chaines allouées. Ca va poser un problème au moment de la libération, vu qu'ici, aucun mécanisme de 'marquage (statique vs dynamique) n'est prévu... A moins de se souvenir exactement que c[0] doit être libéré et pas c[1], ni c[2], ce qui n'est pas vraiment simple à réaliser automatiquement...

c[0] pointe sur l'adresse de c[2] dont l'espace mem contient la chaîne "world".
Que devient la chaîne "world" après strcpy(), on ne peut la modifier en principe puisque c'est une chaîne litérale, alors comment ça se passe ?
Quand on alloue une taille sur la zone de c[0] es-ce que "world" est détruit ?

Non Toute chaine littérale a une durée de vie permanente. Par contre, on a perdu son adresse.

[oranoutan]

ok merci beaucoup Emmanuel Delahaye pour toutes ces réponses, ça commence à s'éclaicir un peu plus.

Il y a encore un petit truc que je n'arrive pas trop à saisir avec strcpy() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
char *p;
 
p = malloc (15  * sizeof *p);
strcpy (p, "bonjour"); // copie la chaine "bonjour" à l'adresse de p
strcpy (p, "au revoir"); // copie la chaine "au revoir" à l'adresse de p

Es-ce que la chaîne "bonjour" est détruite à la fin du programme ? dans le cas contraire elle devrait se situer à la même adresse que la chaîne "au revoir" ?



si la chaîne bonjour ne peut être modifiée

[souviron34]

Il suffit de faire un printf pour s'en rendre compte..

oui la chaine "Bonjour" est détruite.. strcpy écrit à l'adresse que tu passes, et ajoute un '\0' à la fin.

Par contre, tu pourrais faire (mais avec 15 caractères tu n'as pas assez de place ;-) )

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

strcpy ( (p+strlen("bonjour")), "au revoir" ) ;

et tu aurais :

"bonjourau revoir"....

(et tu aurais le même résutat avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

strcat ( p, "au revoir") ;

[oranoutan]

ah d'accord par contre je n'ai pas compris ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

p + strlen("bonjour")

[souviron34]

on peut faire de l'arithmétique (simple) sur les pointeurs...

Comme strcpy écrit une chaîne à une certaine adresse, si tu voulais faire avec strcpy la même chose qu'avec strcat, il faudrait lui passer l'adresse où la chaine précédente se termine (qu'elle ne peut déterminer elle-même, puisqu'elle écrit à l'adresse sans se poser de questions, contrairement à strcat).

Or la chaîne précédente a une longueur de l = strlen("Bonjour") .

Donc la première adresse disponible dans la chaîne p si on veut garder "bonjour" se situe donc à p + l

l = 7

*(p+0) = 'B' ( = *p )
*(p+1) = 'o'
*(p+2) = 'n'
*(p+3) = 'j'
*(p+4) = 'o'
*(p+5) = 'u'
*(p+6) = 'r'
*(p+7) = '\0'

[oranoutan]

génial ce truc!
Merci.

[oranoutan]

Bonjnour,

j'ai un soucis avec ce qui suit, je n'arrive pas à localiser l'erreur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
    int *tabentier=NULL, *pR=NULL, i;
 
    /* Création d'un tableau de 3 entiers */
    pR = malloc ( 3 * sizeof(int*)); // utile ?
    tabentier = malloc ( 3 * sizeof(int*) );
    if (pR == NULL || tabentier == NULL)
    {
        puts("mem prob");
        exit(EXIT_FAILURE);
    }
 
    /* remplissage */
    tabentier[0] = 1;
    tabentier[1] = 2;
    tabentier[2] = 3;
 
    /* Ajout de 2 elements au tableau */
    pR = realloc (tabentier, 5* sizeof(int*) );
    if (pR == NULL) 
    {
        puts("mem prob");
    	exit(EXIT_FAILURE);
    }
 
    /* remplissage */
    pR[3] = 4;
    pR[4] = 5;
 
    for ( i = 0 ; i < 4 ; i++ )
    printf(" pR[%d] = %d \n", i , pR[i] );
 
    free(tabentier);
    free(pR);

[Emmanuel Delahaye]

j'ai un soucis avec ce qui suit, je n'arrive pas à localiser l'erreur :

Tu cherches à libérer 2 fois le même bloc. Le comportement est indéfini. Voici une trace de ce qui se passe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
Usage xxx[ /T][ /E][ /O][ <options application>]
FRMWRK.DBG_SYSALLOC=1
SYSALLOC Overload (85 rec)
SYSALLOC Successful initialization: 85 records available
SYSALLOC 'M 003D2430     12 4294967295    9:main.c'
SYSALLOC 'M 003D2448     12 4294967295   10:main.c'
SYSALLOC 'F 003D2448     20 4294967295   23:main.c'
SYSALLOC 003D2448 matched
SYSALLOC 'R 003D2448     20 4294967295   23:main.c'
 pR[0] = 1
 pR[1] = 2
 pR[2] = 3
 pR[3] = 4
SYSALLOC 'F 003D2448      0 4294967295   37:main.c'
SYSALLOC 003D2448 matched
SYSALLOC 'F 003D2448      0 4294967295   38:main.c'
SYSALLOC 003D2448 not-matched
 
SYSALLOC min=4294967295 max=4294967295 delta=0
SYSALLOC Err: Not-matched list:
SYSALLOC Bloc 003D2430 (12 bytes) malloc'ed at line 9 of 'main.c' not freed
SYSALLOC Bloc 003D2448 freed at line 38 of 'main.c' not allocated
SYSALLOC Released Memory
FRMWRK.Termine

Ton code est beaucoup trop complexe pour fonctionner correctement. Le voici réécrit selon ce principe :

http://emmanuel-delahaye.developpez....es.htm#realloc

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
#define DBG 1
#define ARG 0
#include "frmwrk/inc/main.h"
/* ------------------------------------------------------------ */
//#line 1
#include <stdio.h>
#include <stdlib.h>
 
int main (void)
{
   /* Création d'un tableau de 3 entiers */
   int size = 3;
   int *tab = malloc (size * sizeof *tab);
   if (tab != NULL)
   {
      /* remplissage */
      tab[0] = 1;
      tab[1] = 2;
      tab[2] = 3;
 
      /* Ajout de 2 elements au tableau */
      {
         void *tmp = realloc (tab, (size + 2) * sizeof *tab);
         if (tmp != NULL)
         {
            size += 2;
            tab = tmp;
            /* remplissage */
            tab[3] = 4;
            tab[4] = 5;
         }
         else
         {
            puts ("mem prob");
            free (tab), tab = NULL;
         }
      }
 
      if (tab != NULL)
      {
         int i;
         for (i = 0; i < size; i++)
         {
            printf (" tab[%d] = %d \n", i, tab[i]);
         }
      }
      free (tab), tab = NULL;
   }
   else
   {
      puts ("mem prob");
   }
   return 0;
}

Ce qui donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
Usage xxx[ /T][ /E][ /O][ <options application>]
FRMWRK.DBG_SYSALLOC=1
SYSALLOC Overload (85 rec)
SYSALLOC Successful initialization: 85 records available
SYSALLOC 'M 003D2430     12 4294967295   13:main.c'
SYSALLOC 'F 003D2430     20 4294967295   23:main.c'
SYSALLOC 003D2430 matched
SYSALLOC 'R 003D2430     20 4294967295   23:main.c'
 tab[0] = 1
 tab[1] = 2
 tab[2] = 3
 tab[3] = 4
 tab[4] = 5
SYSALLOC 'F 003D2430      0 4294967295   47:main.c'
SYSALLOC 003D2430 matched
SYSALLOC min=4294967295 max=4294967295 delta=0
SYSALLOC All-matched
SYSALLOC Released Memory
FRMWRK.Termine
 
Press ENTER to continue.

Nota. La trace a été obtenue avec

http://emmanuel-delahaye.developpez.com/clib.htm
Module SYSALLOC