Différence entre ** et &* ?

Version imprimable

Voir 40 message(s) de cette discussion en une page

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.

18/05/2012, 13h18
Neckara

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 **.
18/05/2012, 15h53
Arkenis

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 ?
18/05/2012, 16h28
Neckara

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.
18/05/2012, 16h44
Trademark

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 ;)
18/05/2012, 17h11
Neckara

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.
18/05/2012, 17h38
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 ?
18/05/2012, 17h47
diogene

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.
18/05/2012, 17h53
Neckara

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 *
18/05/2012, 18h05
Arkenis
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 ?
18/05/2012, 18h26
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.
18/05/2012, 21h27
Arkenis

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:
18/05/2012, 21h34
Neckara

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.
18/05/2012, 21h51
Arkenis

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é
   // ...
}

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 ?

19/05/2012, 12h22
Neckara

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.
19/05/2012, 12h29
Arkenis

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 ?
19/05/2012, 12h32
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.
19/05/2012, 12h45
Arkenis
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

Voir 40 message(s) de cette discussion en une page