Warning code bloc

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 :calim2: 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:

---

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; }

---

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.

Bonjour Medinoc,

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

Voici mon main :

Code:

---

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:D

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

Petit up

Merci

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

Code:

---

(*buf++);

---

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

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 :mrgreen: 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 :oops:

Citation:

---

Envoyé par Dev 37C

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

---

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

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

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

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

Bonsoir,

Citation:

---

Envoyé par leternel

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

---

:nono: 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:

---

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

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).