Discussion :

[Dev 37C]

Bonjour

Je suis entrain de faire des essais avec read et write.

Mon problème est que je ne vois pas comment éviter ce warning ligne (*buf++) Ce warning me dit que buf n'est pas utilisée pourquoi??

Ce pointeur est l'adresse ou sera stocké le prochain caractère. I est donc utilisé.

Merci d'avance pour vos réponse. Bonne soirée

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
int lib_enregistreString(char* buf, const size_t n)
{
    int nbCaractere;
 
    nbCaractere = 0;
 
    if(buf == NULL)
        return -1;
 
    while(nbCaractere++ < (int) n-1)// pour garder la place du caractere de fin
    {
        read(STDIN_FILENO, buf, sizeof(char));
 
        if((*buf) == '\n')
            break;
 
        (*buf++);
    }
 
    (*buf) = '\0';
 
    return nbCaractere;
}

[Médinoc]

J'aimerais bien voir le texte exact du warning, mais en gros:
Ton code déréférence le pointeur buf, mais n'utilise pas la valeur pointée. C'est ça qui fait gueuler le compilateur: buf++; suffirait.

[Dev 37C]

Bonjour Medinoc,

voici le phrase exacte : "Value computed is not used [-Wuned-value]"

Voici mon main :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int main(int argc, char* argv[])
{
    char buf[TAILLE];
 
    lib_enregistreString(buf, TAILLE);
 
    printf("\n%s.\n", buf);
 
    getchar();
    return 0;
}

en tout cas, merci pour la rep

[Dev 37C]

Désolé mais je n'ai toujours pas trouvé pourquoi

Petit up

Merci

[Bktero]

Pourtant Médinoc t'as donné la probable solution.

Code :

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

(*buf++);

Que penses-tu que cette ligne fait ? Explique le nous en français.

[Dev 37C]

Bonjour Bktero

Pour moi, *buf++ passe à l'adresse suivante.

EX :

char buf[4] = "Flo" a l'adresse 1000;

buf[0] = 'F' adresse 1000
buf[1] = 'l' adresse 1001
buf[2] = 'o' adresse 1002
buf[3] = '\0' adresse 1003

si j'ai bien compris les pointeurs Ma fonction reçoit un pointeur de type char. L'adresse quelle reçoit est 1000 de ce cas.

dans ma boucle à chaque appel de *buf++ l'adresse prend +1 donc 1000, 1001 ... et s’arrête au caractère '\n' ou quand nbCaractere == n.

Je ne comprend donc pas pourquoi buf est déréférence

[Médinoc]

Je ne comprend donc pas pourquoi buf est déréférencé

Ben, parce que tu mets une étoile devant...

Comme je l'ai dit, pour juste incrémenter le pointeur, buf++; suffit.

[ternel]

En fait, l'étoile désigne toujours le déréférencement (°)

++ à droite est évalué avant *.
ainsi *buf++ s'évalue *(buf++).
buf avance, et l'étoile accède à la nouvelle valeur de buf.




note °: par toujours je veux dire qu'on peut lire int *p comme p est un pointeur d'entier ou comme la mémoire au bout de p est un entier

[Dev 37C]

Merci pour les réponses. Maintenant c'est clair

[Invité]

Bonsoir,

++ à droite est évalué avant *.
ainsi *buf++ s'évalue *(buf++).
buf avance, et l'étoile accède à la nouvelle valeur de buf.

Pour la version postfixée *buf++, c'est l'inverse : d'abord *buf est évalué, puis on incrémente le pointeur buf++.
C'est par contre bien le cas pour la version préfixée *++buf où l'on incrémente d'abord le pointeur avant de le déférencer.

Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
 
int main(void) {
    int tab[10] = {1,2,3,4,5,6,7,8,9,10};
    int *pre = tab;
    int *post = tab;
    int i;
    for (i=0 ; i<9 ; i++)
        printf("%2d - %d\n", *++pre, *post++);
 
    return 0;
}

affiche :

 2 - 1
 3 - 2
 4 - 3
 5 - 4
 6 - 5
 7 - 6
 8 - 7
 9 - 8
10 - 9

[ternel]

D'après operator precedence en C sur cppreference.com.

La priorité de "Suffix/postfix increment and decrement" est 1, supérieure à celle de "Prefix increment and decrement" et "Indirection (dereference)" (2).
Du coup, *p++ est évalué comme *(p++).

Sauf si ce site se trompe, ce qui m'étonnerais quand même, vu que wikipedia dit la même chose, tout comme mon petit "C précis et concis".
Il faudrait que je mette la main sur la norme elle-même pour être parfaitement certain.


Par contre, là où j'ai fumé, c'est que le ++ postfixe retourne la valeur avant incrémentation.
Le problème du compilateur, c'est que *p++ est une expression composée, dont la valeur finale est celle d'un opérateur non modifiant (*), au contraire d'un simple p++.

Du coup, comme instruction, *p++; a pour effet de calculer une valeur sans rien en faire, tandis que dans p++; la dernière opération modifie la valeur.
Le compilateur dit juste que l'étoile est inutile (sauf à éventuellement causer une segfault).