Différence entre ** et &* ?

Bonjour,

J'aimerais comprendre pourquoi 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

int main(int argc, char ** argv){ int n = 0; size_t taille = 0; char *c1; char *c2; char *saveptr;     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; }

---

Et celui ci me sort une erreur de segmentation:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

int main(int argc, char ** argv){ int n = 0; size_t taille = 0; char *c1; char *c2; char **saveptr;     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; }

---

Sachant que le prototype de strtok_r est:

Citation:

---

char *strtok_r(char *str, const char *delim, char **saveptr);

---

Je croyais que un pointeur1 de pointeur2 contenais l'adresse de pointeur2, equivalent a &pointeur2.

Déclarer un pointeur ne suffit pas, il faut aussi allouer l'espace.

Tu as un char ** mais sur quoi pointe-t-il?

Lorsque tu utilises ta fonction, il va faire une copie de ton char ** puis il va écrire un pointeur char * dans l'objet pointé par ton char ** or tu n'as pas alloué l'espace pour le char * pointé par ton char **.

Ha oui, j'oublie a chaque fois..
Toutefois, je comprend pas pourquoi le premier code fonctionne du coup, simple coup de chance que la mémoire ne soit pas déjà allouée ?

strtok_r dois allouer l'espace mémoire pour contenir les caractères mais il n'alloue pas le char *.

Après, en regardant le man, on devrait avoir plus d'informations.

Salut,

Comme pour toutes variables, si vous voulez modifier la valeur, il faut alors passer son adresse. Ici le type concerné est char*, en passant son adresse on a un char**.

Je présume que strtok_r fait quelque chose comme *saveptr = &str[i];. Tu ne pourrais pas mettre à jour saveptr de cette façon si tu passais un char*. Du coup avec ton deuxième code je te laisse imaginer ;)

Dans son deuxième code saveptr est un char ** et non un char *.

A par le fait que saveptr ne pointe pas sur un char * alloué, je ne vois pas pourquoi son deuxième code ne marcherait pas.

Le deuxième code fonctionne si j'alloue de la mémoire pour **saveptr, mais pourquoi l'allocation n'est pas nécessaire si je déclare *saveptr et non **saveptr ?

c1 devrait être initialisé à NULL avant le premier appel à getline()

Cf man pages

Citation:

---

ssize_t getline(char **lineptr, size_t *n, FILE *stream);
......
getline() lit une ligne entière dans stream et stocke l'adresse du tampon contenant le texte dans *lineptr. Le tampon se termine par un caractère nul et inclut le caractère « saut de ligne » s'il y en a un.
Si *lineptr vaut NULL, getline() alloue un tampon pour recevoir la ligne. Ce tampon devra être libéré par le programme utilisateur. (La valeur dans *n est ignorée). Alternativement, avant d'appeler getline(), *lineptr peut contenir un pointeur vers un tampon alloué par malloc(3) et de taille *n octets. Si le tampon n'est pas suffisant pour recevoir la ligne saisie, getline() le redimensionne avec realloc(3), mettant à jour *lineptr et *n comme il se doit.

---

Citation:

---

Envoyé par Arkenis

Le deuxième code fonctionne si j'alloue de la mémoire pour **saveptr, mais pourquoi l'allocation n'est pas nécessaire si je déclare *saveptr et non **saveptr ?

---

char * saveptr : il faut allouer un/des char
char ** saveptr : il faut allouer un/des char * et pour chaque char * allouer un/des char

Or je pense que ta fonction alloue l'espace pour les char donc :

char * saveptr : rien à faire, ta fonction alloue les char
char ** saveptr : il faut allouer un/des char * et ta fonction allouera les char pour le premier char *

Citation:

---

Envoyé par diogene

c1 devrait être initialisé à NULL avant le premier appel à getline()

Cf man pages

---

c1 n'est-il pas automatiquement initialisé a NULL ?

Code:

---

1 2 3 4 5 6 7 8 9

int main(int argc, char ** argv){   char *c1; printf("c1 = %p\n", c1); c1 = NULL; printf("c1 = %p\n", c1);   return 0; }

---

Citation:

---

c1 = (nil)
c1 = (nil)

---

Y a-t-il un lien avec saveptr ?

Il me semble que seul les variables globales sont initialisées à NULL.

Pour toutes les autres variables, le contenu est indéterminé, le fait que c1 vaut NULL s'il n'est pas initialisé est sûrement dû à un coup de chance.

Citation:

---

Envoyé par Neckara

char * saveptr : rien à faire, ta fonction alloue les char
char ** saveptr : il faut allouer un/des char * et ta fonction allouera les char pour le premier char *

---

Certes, mais ce n'est pas le contenu de *saveptr qu'on passe en paramètre, mais l'adresse de celui-ci, ce qui revient au même qu’écrire le contenu d'un pointeur qui pointe sur *saveptr (= **saveptr non ?), du moins, c'est ce que je croyais :cry:

si tu as un char * x; et que tu fais &x tu obtient un char ** qui pointe vers x et x existe.

si tu as un char **x; et que tu fais x tu as toujours un char ** mais il pointe n'importe où. D'où l'apparition d'un SEGFAULT.

Je pense avoir compris, mais une allocation préalable est nécessaire dans le cas ou on déclare char *x, sinon x n'existe pas en mémoire, tout comme pour char ** x qui pointe sur quelque chose qui n'existe pas si on ne lui alloue pas d'espace, et donc le fait que ça marche sur mon tout premier code sans allouer de mémoire pour char * saveptr n'est qu'un coup de chance non ?

Citation:

---

le fait que ça marche sur mon tout premier code sans allouer de mémoire pour char * saveptr n'est qu'un coup de chance non ?

---

Non parce que strtok_r n'a pas besoin que char* saveptr soit alloué car il n'utilise pas saveptr comme un chaine de caractère en soi mais comme une variable pour se souvenir d'un pointeur existant ! Un peu comme un indice lorsque tu parcours un tableau.

Donc tu peux imaginer que strtok_r fait ça :

Code:

---

1 2 3 4 5 6

char *strtok_r(char *str, const char *delim, char *saveptr)   1) Parcourt str jusqu'à rencontrer un délimiteur. 2) Lorsqu'on a rencontré un délimiteur, on veut pouvoir sauvegarder où on est arrivé, pour pouvoir continuer par la suite. Donc on fait par exemple :   saveptr = &str[indice_courant];

---

Dans le code du dessus, le problème c'est que saveptr est copié par valeur, donc saveptr est une variable locale et modifier le contenu d'une variable locale, qui est ici une adresse, n'est pas vu de "l'extérieure" de la fonction. Si on veut pouvoir modifier l'adresse vers laquelle pointe un pointeur, il faut passer l'adresse de ce pointeur... Et faire:

Code:

---

1 2 3 4 5

char *strtok_r(char *str, const char *delim, char **saveptr) { *saveptr = &str[indice_courant]; // ... }

---

Alors là, les modifications sont vues en dehors de la fonction vu que *saveptr n'est pas local à la fonction contrairement à saveptr.

Dans le premier exemple *saveptr pointe vers un char... Pas pratique pour stocker une adresse.

Si j'ai bien compris cette fois-ci, on a:

Code:

---

1 2 3 4 5 6 7 8 9

char *saveptr; /* Dans ce cas saveptr est stocké dans la mémoire, seul son contenu vaut NULL c'est bien ca ? Ici saveptr est alloué, et la valeur sur laquelle il pointera par la suite l'est deja aussi */   char *strtok_r(char *str, const char *delim, char &*saveptr){   *saveptr = &str[indice_courant]; //Au lieu de valoir NULL, le contenu de saveptr vaudra désormais &str[indice_courant], qui est déjà alloué // ... }

---

Et

Code:

---

1 2 3 4 5 6 7 8 9

char ** saveptr; /* Ici, saveptr est en mémoire, de même que str, mais le pointeur "entre les deux" ne l'est pas */ char *strtok_r(char *str, const char *delim, char **saveptr) { /* On demande alors au pointeur sur lequel saveptr pointe, qui n'est pas alloué ici,  de pointer sur str[indice_courant], d'ou l'erreur de segmentation */ *saveptr = &str[indice_courant]; // ... }

---

C'est bien ça ?

Comme je l'ai dit :

Citation:

---

Envoyé par Neckara

Il me semble que seul les variables globales sont initialisées à NULL.

Pour toutes les autres variables, le contenu est indéterminé, le fait que c1 vaut NULL s'il n'est pas initialisé est sûrement dû à un coup de chance.

---

Déclarer une variable ne l'initialise pas (sauf pour les variables globales).
Le contenu d'une variable déclarée et non initialisée est indéterminé.

C'est pour cela que Diogene te dis qu'il faut initialiser c1 à NULL avant d'appeler getline.

Autant pour moi, au lieu de dire que saveptr pointe sur NULL dans le premier cas, j'aurais du dire qu'il pointe sur n'importe quoi, mais sinon ce que j'ai dit est correct non ?

Tes commentaires juste avant l'appel de la fonction strtok_r sont un peu ambigüe. Quand tu dis 'ici' considères-tu que tu es dans la fonction strtok_r ou que tu es après la déclaration de ton pointeur?

L'allocation du tableau de caractère se fait dans strtok_r.

Citation:

---

Envoyé par Neckara

Tes commentaires juste avant l'appel de la fonction strtok_r sont un peu ambigüe. Quand tu dis 'ici' considères-tu que tu es dans la fonction strtok_r ou que tu es après la déclaration de ton pointeur?

L'allocation du tableau de caractère se fait dans strtok_r.

---

Je considère qu'on est après la déclaration du pointeur, pourquoi une allocation dans la fonction strtok_r serait necessaire si on fait pointer saveptr sur un contenu déjà alloué (str en l'occurence)? L'allocation n'est-elle pas nécessaire uniquement pour pointer sur un contenu "nouveau" ?
Du style:

Code:

---

1 2	char *c = malloc(4); strcpy(c, "Hey"); // On alloue car il faut stocker "Hey" qui est un nouveau contenu

---

Mais:

Code:

---

1 2 3 4

char *c; char *str = malloc(4); strcpy(str, "Hey"); c = str; //Le contenu est déjà alloué, pas besoin d'une autre allocation pour c

---

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