code qui lit le temps

Bonjour

j'ai une code qui fonctionne mais dont je n'arrive pas en saisir la structure
et je sollicite votre aide pour comprendre
voici le code :

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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

#include <stdio.h> #include <stdlib.h>   typedef struct { int heure, minute, seconde;   } temps;     entree(temps *t) {   t->heure=99; t->minute=99; t->seconde=99;   while ((t->heure<0)||(t->heure>23)) { printf("entré les heures : "); scanf ("%i",&t->heure); if ((t->heure<0)||(t->heure>23)) { printf ("temps invalide... veuillez recommencer\n"); } }   while ((t->minute<0)||(t->minute>59)) { printf("entré les minute : "); scanf ("%i",&t->minute); if ((t->minute<0)||(t->minute>59)) { printf ("temps invalide... veuillez recommencer\n"); } }   while ((t->seconde<0)||(t->seconde>59)) { printf("entré les seconde : "); scanf ("%i",&t->seconde); if ((t->seconde<0)||(t->seconde>59)) { printf ("temps invalide... veuillez recommencer\n"); } } }   sortie(temps *t) { printf ("le temps est %i:%i:%i\n",t->heure,t->minute,t->seconde); }   int main() { temps t; entree (&t); sortie (&t); }

---

les partie du code que j'ai du mal à comprendre

Code:

---

1 2 3 4 5 6 7

typedef struct { int heure, minute, seconde;   } temps;

---

Code:

---

1 2 3

entree(temps *t) sortie(temps *t)

---

Code:

---

1 2

t->

---

si vous pouvez me "vulgariser" la compréhension de ces parties, merci

Citation:

---

Envoyé par bosk1000

les partie du code que j'ai du mal à comprendre

Code:

---

1 2 3 4 5 6 7

typedef struct { int heure, minute, seconde;   } temps;

---

---

Bonjour
Il s'agit ici d'une création (typedef) d'un nouveau type (comme char, long, double, etc). Tu peux maintenant créer une variable "toto" de type "temps" de cette façon => temps toto; exactement comme tu aurais créé une variable "tata" de type "double" => double tata;.

Sauf qu'à la différence de "tata" qui reste un truc simple, "toto" est un type structuré (struct) lequel contient 3 membres individuels. C'est ce qu'on nomme une "structure" (un regroupement d'éléments multiples sous une même entité manipulable). Tu peux donc maintenant manipuler indifféremment chaque membre "heure", "minute" ou "seconde" de toto => toto.heure=xxx; toto.minute=yyy; toto.seconde=zzz; etc...

Il est toutefois d'usage de nommer ses types "t_" pour plus de clarté. Ca ne change rien au principe mais ça rend de suite le code plus lisible (pouvoir différencier plus facilement "type" et "variables")...

Code:

---

1 2 3 4 5 6

typedef struct { int heure, minute, seconde; } t_temps;   t_temps toto;

---

Citation:

---

Envoyé par bosk1000

Code:

---

1 2 3

entree(temps *t) sortie(temps *t)

---

---

Oui ben il serait temps d'ouvrir un livre de C au chapitre des fonctions et des pointeurs. Tes deux fonctions reçoivent en paramètre l'adresse d'une variable de type "temps".

Citation:

---

Envoyé par bosk1000

Code:

---

t->

---

---

L'accès à un membre "xxx" d'une structure dont on n'a qu'un pointeur "pt" se fait par le biais des référencements classique (*pt).xxx qui se lira "le membre "xxx de la structure pointée par pt". Mais la priorité des opérateurs (l'opérateur "point" étant plus prioritaire que l'opérateur "étoile") impose l'utilisation des parenthèses ce qui devient lourd.
Il a alors été créé l'opérateur "flèche" remplissant exactement le même rôle mais plus simple à écrire pt->xxx. Il faut juste ne jamais oublier que la flèche signifie que c'est l'élément placé avant celle-ci qui est un pointeur (ici "pt")...

Merci pour ces information
je vais bien lire attentivement et assimiler

salut,

Citation:

---

Envoyé par bosk1000

Code:

---

1 2 3

entree(temps *t) sortie(temps *t)

---

---

je me permets de compléter ce que dit Sve@r, on est d'accord qu'on parle ici de la déclaration des fonctions entree() et sortie(), pas de leur invocation
une déclaration crado, il faut lire implicitement :

Code:

---

1 2 3 4 5 6

void entree (temps *t) { (...) } void sortie (temps *t) { (...) }

---

(c'est le void qui est implicite, les accolades sont bien là dans ton code, mais c'est mal indenté :mouarf:)

Citation:

---

Envoyé par BufferBob

je me permets de compléter ce que dit Sve@r, on est d'accord qu'on parle ici de la déclaration des fonctions entree() et sortie()...

---

Si on veut être vraiment précis, ce serait plus une définition qu'une déclaration...

Citation:

---

Envoyé par BufferBob

une déclaration crado, il faut lire implicitement :

Code:

---

1 2 3 4 5 6

void entree (temps *t) { (...) } void sortie (temps *t) { (...) }

---

(c'est le void qui est implicite

---

Hum, me semble qu'une fonction non typée est alors automatiquement typée int ;)

salut,

Citation:

---

Envoyé par Sve@r

Hum, me semble qu'une fonction non typée est alors automatiquement typée int ;)

---

t'es sûr de ça ? ça me paraitrait plus logique qu'un type omis corresponde implicitement à un void plutôt qu'à un int qui forcerait le compilateur à considérer une valeur de retour implicite/par défaut
si c'est le cas il manque aussi un return dans chacune de ses fonctions du coup

@BufferBob : Sve@r est dans le vrai. Cela remonte à la protohistoire du C, le fameux K&R C qui spécifiait à l'époque que si un type était omis alors par défaut ce serait un entier. Je parle de protohistoire dans le sens d'«avant les normalisations». Cette syntaxe est devenue obsolète avec les normes ANSI89 et ISO90. Depuis C99 cette syntaxe doit faire émettre un message de diagnostic au compilateur. Par exemple :

Code:

---

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

#include <stdio.h>   f() { static a=0; return a++; }     g(a,b) { return a+b; }   main() {   printf("a=%d\n",f()); printf("a=%d\n",f()); printf("a=%d\n",f());   printf("2+3=%d\n",g(2,3)); }

---

Ne donne aucun message si tu compile en C89 :

Code:

---

1 2	$ gcc -std=c89 -o impl impl.c $

---

En revanche, si tu compiles en C99 ou C11 :

Code:

---

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

$ gcc -std=c99 -o impl impl.c impl.c:3:1: warning: return type defaults to ‘int’ f() { ^ impl.c: In function ‘f’: impl.c:4:10: warning: type defaults to ‘int’ in declaration of ‘a’ static a=0; ^ impl.c: At top level: impl.c:9:1: warning: return type defaults to ‘int’ g(a,b) { ^ impl.c: In function ‘g’: impl.c:9:1: warning: type of ‘a’ defaults to ‘int’ impl.c:9:1: warning: type of ‘b’ defaults to ‘int’ impl.c: At top level: impl.c:13:1: warning: return type defaults to ‘int’ main() { ^

---

Edit: pour une source voir The C programming language, page 61 :

Citation:

---

Each function definition has the form
return-type function-name(argument declarations)
{
declarations and statements
}
Various parts may be absent; a minimal function is
dummy() {}
which does nothing and returns nothing. A do-nothing function like this is sometimes useful as
a place holder during program development. If the return type is omitted, int is assumed.

---

Citation:

---

Envoyé par picodev

(...) Cette syntaxe est devenue obsolète avec les normes ANSI89 et ISO90. Depuis C99 cette syntaxe doit faire émettre un message de diagnostic au compilateur. (...) voir The C programming language, page 61 :

---

oui j'ai lu ça aussi dans la journée, bien vu 8-)
merci de cet éclaircissement à tous les deux j'aurais appris un truc

Merci pour vos intervention

ceci éclaire ma petite led qui me sert de lumière