Différence entre ** et &* ?

Si j'ai bien compris le man, le troisième argument sert de buffer.

Mais si strtok_r ne fait qu'une simple affectation :

Code:

---

1 2 3 4 5 6 7

char *strtok_r (char *s, const char *delim, char **ptrptr) { if(s != NULL) *ptrptr = s;   }

---

Si entre deux strtok_r ont modifie la chaîne de caractère, on va modifier le contenu pointé par ptrptr.

Il est bien plus probable que strtok_r fasse :

Code:

---

1 2 3 4 5 6 7 8 9 10

char *strtok_r (char *s, const char *delim, char **ptrptr) { if(s != NULL) { *ptrptr = malloc(sizeof(char)*(strlen(s)+1)); strcpy(*ptrptr, s); }   }

---

De plus ptrptr est un buffer, il doit donc sûrement être modifié à chaque utilisation de strtok_r sans modifier s.


EDIT : http://www.student.cs.uwaterloo.ca/~...8c-source.html

Apparement strtok_r ne fait qu'une simple affectation. Il faut donc faire attention lorsqu'on l'utilise (c'est pas une fonction très sûre et très propre).

strtok_r() n'alloue rien du tout, car il modifie directement s.

Citation:

---

Si entre deux strtok_r ont modifie la chaîne de caractère, on va modifier le contenu pointé par ptrptr.

---

Tu n'es pas supposé la modifier, ça rentrerait en conflit avec les modifs faites par strtok_r().. Tu n'est pas d'ailleurs supposé toucher à *ptrptr non plus, c'est strtok_r() qui l'utilise en interne.

En définitive, on a donc:

Dans le cas ou on déclare char *c:
- &c -> c (défini)-> *c //Aucune erreur

Dans le cas ou on déclare char **c;
- c -> *c (non défini) -/> **c //Erreur de segmentation

Par conséquent ce code fonctionne:

Code:

---

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

int main(int argc, char ** argv){ int n = 0; size_t taille = 0; char *c1 = NULL; char *c2; char *c3; char **saveptr;   saveptr = c3; //On définit le pointeur "intermédiaire"     while(getline(&c1, &taille, stdin) != -1){ printf("Ligne %d\n", ++n); c2 = strtok_r(c1, "\t ", saveptr);   while(c2 != NULL){ printf("\t%s\n", c2); c2 = strtok_r(NULL, "\t ", saveptr); } }   printf("\nDone\n");   return 0; }

---

Code:

---

saveptr = &c3;

---

Ton compilo devrait te donner au moins un warning pour ce genre de truc.

Oula, non ton code ne fonctionne pas, ou en tout n'est pas sensé fonctionné, ou alors plantera un jour..

Je comprend que tu t’emmêles les pinceaux, alors je te conseille de prendre une feuille de papier et de te représenter la mémoire dans des cases, en indiquant pour chaque case: son contenu et son adresse (et éventuellement le type de la case).

Par exemple, ce que tu fais avec :

Code:

---

1 2 3

char *c3; char **saveptr; saveptr = c3;

---

Je peux pas dessiner mais en listant les attributs on obtient :

c3

• contenu : N'IMPORTE QUOI (car non-initialisé).
• adresse : 0x8984 (par exemple..., adresse sur 2 octets par simplicité - normalement c'est sur 8 octets)
• type : char*

saveptr

• contenu : N'IMPORTE QUOI (car non-initialisé).
• adresse : 0x9984 (par exemple..., adresse sur 2 octets par simplicité - normalement c'est sur 8 octets)
• type : char** - ou pointeur vers char*

Après l'affectation saveptr = c3; :

saveptr

• contenu : LE N'IMPORTE QUOI de c1 (car non-initialisé).
• adresse : 0x9984 (par exemple..., adresse sur 2 octets par simplicité - normalement c'est sur 8 octets)
• type : char** - ou pointeur vers char*

Maintenant je vais essayer de te faire comprendre d'une autre façon.

Imaginons qu'on a une fonction qui modifie un entier tu dois faire:

Code:

---

void modifie_entier(int *a){ *a = 42; }

---

On sait que char* est une chaine de caractère, donc on pourrait écrire :

Code:

---

typedef char* adresse_debut_chaine;

---

adresse_debut_chaine est maintenant un type comme int ou float ou n'importe quoi. On peut (presque) oublié que c'est un char*.

Si tu veux modifier l'adresse du début de ta chaine de caractère tu dois faire :

Code:

---

1 2	void modifie_string(adresse_debut_chaine *a) { // ... }

---

Ce qui reviens à passer en argument char**.

Revenons à nos moutons, strtok_r se promène sur un char*, comme tu sais (ou pas) les données sont contiguës en mémoire donc pour char* c1 = "hello"; tu as 5 char qui sont situés côte à côte. c1 commence par une adresse, et si tu fais *c1 tu as la première lettre du mot. Si tu fais *(c1 + sizeof char) tu as la deuxième lettre du mot, etc. On peut donc dire que c1 + sizeof char est l'adresse de la deuxième lettre du mot. strtok_r lui veut justement se souvenir de l'adresse de là où il est arrivé (c'est-à-dire à un délimiteur). Donc il va sauvegarder dans *saveptr l'adresse du caractère où il est arrivé. (Rappel que *saveptr est de type char* (note bien '*' devant saveptr).

Tu veux donc modifier le contenu d'un pointeur. Vu que un pointeur est un type, ici char*, il faut bien passer son adresse pour que son contenu soit effectivement modifié.

Je te conseille vivement de prendre tes crayons et de dessiner des carrés avec dedans le contenu et à l'extérieur l'adresse et des flèches entre les différents carrés pour dire qu'un pointeur "pointe" vers une autre adresse... Tu verras alors que le contenu du carré sera le même que l'adresse d'un autre carré.

Citation:

---

Envoyé par Médinoc

Code:

---

saveptr = &c3;

---

Ton compilo devrait te donner au moins un warning pour ce genre de truc.

---

Effectivement, a force de me prendre la tête la dessus, j'y ai pas prêté attention, et la première exécution a marché, celle que je viens de faire a plantée, c'est une erreur d'inattention :?

Citation:

---

Je te conseille vivement de prendre tes crayons et de dessiner des carrés avec dedans le contenu et à l'extérieur l'adresse et des flèches entre les différents carrés pour dire qu'un pointeur "pointe" vers une autre adresse... Tu verras alors que le contenu du carré sera le même que l'adresse d'un autre carré.

---

Le contenu de **saveptr contient l'adresse de c3, right ? Ainsi, l'utilisation du pointeur1 de pointeur2 permet de modifier l'adresse pointée par pointeur2 dans une fonction

Tu mélanges tout avec ta manière de formuler les choses :

Citation:

---

Code:

---

1 2 3

char *c3; char **saveptr; saveptr = c3;

---

Le contenu de **saveptr contient l'adresse de c3, right ?

---

Non. le contenu de saveptr est l'adresse contenue dans c3 (un char *, et le type de saveptr devrait être aussi char *, pas char **)

Par contre si on a saveptr = &c3;,
- le contenu de saveptr (et pas de **saveptr) est l'adresse de c3 (et le type de saveptr est bien char**)
- Alors, *saveptr == *&c3 == c3 ; *saveptr désigne l'objet c3
- et **saveptr == *c3 autrement dit désigne le char à l'adresse contenue dans c3

Nous sommes bien d'accord,

Citation:

---

Envoyé par Arkenis

Le contenu de **saveptr contient l'adresse de c3, right ? Ainsi, l'utilisation du pointeur1 de pointeur2 permet de modifier l'adresse pointée par pointeur2 dans une fonction

---

Je faisais référence au code ou

Code:

---

saveptr = &c3;

---

EDIT:
Par "Le contenu de **saveptr contient l'adresse de c3", j'entend:

Code:

---

1 2 3 4 5 6

char **saveptr; saveptr = &c3;   saveptr == &c3; *saveptr == c3; **saveptr == *c3

---

Dire "Le contenu de saveptr est l'adresse de c3" serait effectivement plus approprié, autant pour moi

Ce qui revient exactement au meme que ce que tu a dis