Boinsoir, voilà je veux stocker dans un pointeurs des chaînes mais j'obtiens le retour suivant :

tab [0]: Jesus
tab [1]: Marie
tab [2]: Joseph
tab [3]: Le Diable
*** stack smashing detected ***: <unknown> terminated
Abandon (core dumped)

Je ne sais pas du tout à quoi cela correspond, j'espère que vous pourrez m'aider

Voici le code :

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef char* MString; // le type chaine de caracteres

typedef struct pile_string {
  MString* tab; // tab[0], tab[1], ... sont les chaines de la pile
  int sommet ; // de la pile
  int sommetMax ; // de la pile
} PileString ;

void initialiser(PileString* p, int tailleMax){
  p->sommet = 0;
  p->sommetMax = tailleMax;
}

void empiler(PileString* p, char* v){
  char* chaine = (char*) malloc(sizeof(char*));
  chaine = v;
  MString val = chaine;
  MString MSchaine = (MString) malloc(sizeof(MString));
  MSchaine = val;
  if(p->sommet < p->sommetMax){
    p->tab = &val;
    p->tab[p->sommet] = MSchaine;
    printf("tab [%d]: %s\n", p->sommet ,p->tab[p->sommet]);
    p->sommet++;
  }
}

char* depiler(PileString* p){
  MString val;
  char* v;
  if(p->sommet > 0){
    p->sommet--;
    val = p->tab[p->sommet];
    v = val;
  }
  return v;
}

void afficher(PileString* p){
  for(int i = 0; i < p->sommet; i++){
    printf("%s\n", p->tab[i]);
  }
}

int pileVide(PileString p){
  return p.sommet == 0;
}

void main(){
  PileString p1;

  initialiser(&p1, 10);
  char t[4][20] = {"Jesus", "Marie", "Joseph", "Le Diable"};
  
  for(int i = 0; i < 4; i++){
    empiler(&p1, t[i]);
  }
  
   
  //afficher(&p1);

  /* Reste du programme 
  PileString p2;
  initialiser(&p2, 20);
  while(pileVide(p1) == 0){
    empiler(&p2, depiler(&p1));
  }

  initialiser(&p1, 20);
  while(pileVide(p2) == 0){
    empiler(&p1, depiler(&p2));
  }

  afficher(p1);*/
}

-
Edité par Anonyyyyyyyyyyyyyyyyyymeee 8 février 2019 à 8:30:06

Bonjour,

tu sais que tes malloc ne servent à rien, tel que tu les fais ?

void empiler(PileString* p, char* v){
  char* chaine = (char*) malloc(sizeof(char*));
  chaine = v;
  MString val = chaine;
  MString MSchaine = (MString) malloc(sizeof(MString));
  MSchaine = val;

tu reserves 4 octets(taille d'un char*) et tu donnes l'adresse de ce bloc memoire à chaine.

Puis tu dis, chaine va pointé au même endroit que v.

Puis val va pointé au même endroit que chaine (donc que v)

tu reserves 4 octets(taille d'un char*) et tu donnes l'adresse de ce bloc memoire à MSchaine.

Puis tu dis, MSchaine va pointé au même endroit que val(donc que chaine , donc que v).

Arrivé à ta ligne 24, tu as un mapping mémoire qui ressemble à cela:

Merci de ta réponse, donc pour les malloc, il faudrait que je copie le contenu (strcpy) au lieu de les pointer ?

Au passage pourrais-tu me dire quel outils a tu utilisé pour voir ce mapping ?

EDIT:

J'ai changé comme ceci

void empiler(PileString* p, char* v){
  char* chaine = (char*) malloc(sizeof(char*));
  strcpy(chaine, v);
  MString val = chaine;
  MString MSchaine = (MString) malloc(sizeof(MString));
  strcpy(MSchaine, val);
  if(p->sommet < p->sommetMax){
    p->tab = &val;
    strcpy(p->tab[p->sommet], MSchaine);
    printf("tab [%d]: %s\n", p->sommet ,p->tab[p->sommet]);
    p->sommet++;
  }
}

et maintenant j'ai le retour suivant :

tab [0]: Jesus
tab [1]: Marie
tab [2]: Joseph
Erreur de segmentation (core dumped)

Je ne trouve pas pourquoi j'écris sur une zone qui ne met pas réservé

-
Edité par Anonyyyyyyyyyyyyyyyyyymeee 8 février 2019 à 11:47:13

Bonjour, j'utilise netbeans en mode debug.

Tu ne réserve pas assez de place avec ton malloc.

Essayes:

char* chaine = (char*) malloc((strlen(v)+1)*sizeof(char*));

Bonsoir, j'ai réessayer avec ton code :

char* chaine = (char*) malloc((strlen(v)+1)*sizeof(char*));

Mais j'ai toujours le même résultat :

tab [0]: Jesus
tab [1]: Marie
tab [2]: Joseph
Erreur de segmentation (core dumped)

Hello,

1) ne jamais cacher un pointeur derrière un typedef, ce sont les emmerdements assurés

2) dans ton dernier code, ligne 5: tu alloues pour MSchaine sizeof(MSstring), soit la taille d'un pointeur (4 ou 8 octets), et dans cet espace tu copies le string v ? 

Pour résumer:

char *chaine = malloc((strlen(v)+1)*sizeof(char));		// changement char * en char
strcpy(chaine, v);										// copie v dans chaine
MString val = chaine;									// val <- adresse de chaine
MString MSchaine = (MString) malloc(sizeof(MString));	// alloue 4/8 octets à MSchaine
strcpy(MSchaine, val);									// copie val, donc chaine, donc v, dans MSchaine ?????

-
Edité par edgarjacobs 9 février 2019 à 1:12:29

accessoirement,

• sizeof(char) est toujours 1,

•  1 est toujours l'élément neutre de la multiplication, tant à gauche qu'à droite.

• la fonction standard POSIX qui fait malloc(strlen) + strcpy s'appelle strdup. (XOPEN_SOURCE >= 500)
  
  

-
Edité par michelbillaud 9 février 2019 à 11:32:56

Merci de vos réponses, donc je devrais utiliser la fonction strdup sur char *v si j'ai bien compris ?

Pour voir si tu as bien compris, tu devrais ESSAYER  sans nous demander.

De préférence dans un autre tout petit programme fait spécialement pour ca. Pas au milieu de ton projet en chantier.

-
Edité par michelbillaud 10 février 2019 à 17:42:25