Discussion :

[dicovid]

bonjour, j'ai un devoir à faire en c pour apprendre à utiliser les structures, le but de cette exercice est de comparer 2 temps hh/mn/ss, j'arrive a saisir un temps en utilisant la fonction entree() mais je ne sais pas comment garder en mémoire le premier temps saisi en T1 puis de saisir un deuxième temps en T2 afin de les comparer par la suite dans une fonction diff(t1,t2)

voila le code que j'ai cré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
 
struct temps
            { int heures;
              int minutes;
              int secondes;
            };
 
entree()
{
struct temps e;
printf("entrez heure  minutes  secondes ");
scanf("%d %d %d",&e.heures,&e.minutes,&e.secondes);
}
 
main()
{
entree();/*utilisé pour t1*/
entree();/*utilisé pour t2*/
 
}

[Skyounet]

Alors tout simplement il faudrait que tu passes un pointeur sur ta structure à remplir.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
entree(struct temps *e)
{
printf("entrez heure  minutes  secondes ");
scanf("%d %d %d", &e->heures, &e->minutes, &e->secondes);
}
 
main()
{
struct temps s1, s2;
entree(&s1);/*utilisé pour t1*/
entree(&s2);/*utilisé pour t2*/
}

Je voudrais aussi rajouter que le prototype de main n'est pas conforme

int main(void)
ou
int main(int argc, char **argv)

Ensuite ta fonction de saisie n'est pas très sécurisé (que se passe t-il si l'utilisateur entre une lettre à la place d'un chiffre ?).

[Freed0]

Salut

Premièrement, pense à utiliser la balise CODE pour présenter ton code, ce sera bien plus clair

Ensuite pour ton exercice : il faut stocker le résultat de la saisie dans une structure déclarée dans ta fonction main. Tu as 2 possibilités :

- Soit ta fonction retourne une structure qui sera copiée dans la variable.
- Soit ta fonction modifie directement la variable via un pointeur.

En gros :

1er cas :

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
struct temps
entree (void)
{
    struct temps e = {0};
 
    /* Ton traitement ici */
 
    return e;
}
 
int
main (void)
{
    struct temps t1 = {0};
    struct temps t2 = {0};
 
    t1 = entree ();
    t2 = entree ();
 
    return 0;
}

2ème cas :

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
void
entree (struct temps *e)
{
    /* Traitement (n'oublie pas que c'est un pointeur de structure
     * => Utilisation du -> pour affecter une valeur) */
}
 
int
main (void)
{
    struct temps t1 = {0};
    struct temps t2 = {0};
 
    entree (&t1);
    entree (&t2);
 
    return 0;
}

Voilà

[Foobar1329]

Hello,

bonjour, j'ai un devoir à faire en c pour apprendre à utiliser les structures, le but de cette exercice est de comparer 2 temps hh/mn/ss, j'arrive a saisir un temps en utilisant la fonction entree() mais je ne sais pas comment garder en mémoire le premier temps saisi en T1 puis de saisir un deuxième temps en T2 afin de les comparer par la suite dans une fonction diff(t1,t2)

voila le code que j'ai crée:

struct temps
{ int heures;
int minutes;
int secondes;
};

entree()
{
struct temps e;
printf("entrez heure minutes secondes ");
scanf("%d %d %d",&e.heures,&e.minutes,&e.secondes);
}

main()
{
entree();/*utilisé pour t1*/
entree();/*utilisé pour t2*/

}

Il faut pouvoir soit renvoyer une copie de la structure créée par la fonction entree, soit utiliser les pointeurs (c'est mieux).

Exples :


Par copie en retour,

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
24
25
26
#include <stdio.h>
 
struct temps { 
   int heures;
   int minutes;
   int secondes;
};
 
struct temps entree(void)
{
    struct temps e;
    printf("entrez heure  minutes  secondes ");
    scanf("%d %d %d",&e.heures,&e.minutes,&e.secondes);
    return e;
}
 
int main(void)
{
   struct temps t1, t2;
   t1 = entree();   
   t2 = entree();
 
   /* traitement ici */   
 
   return 0;
}

Par copie en retour,

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
24
25
26
27
28
#include <stdio.h>
 
struct temps { 
   int heures;
   int minutes;
   int secondes;
};
 
void entree(struct temps * t)
{
    if (t) {
       printf("entrez heure  minutes  secondes ");
       scanf("%d %d %d",t->heures,t->minutes,t->secondes);
       return e;
    }
}
 
int main(void)
{
   struct temps t1, t2;
   /* t1 et t2 en In-Out sont mis à jour par la fonction entree() */
   entree(&t1);   
   entree(&t2);
 
   /* traitement ici */   
 
   return 0;
}

La deuxième solution est à privilégier car dans le cadre de grosses structures, il est beaucoup plus couteux de copier le contenu effectif de la structure que son adresse en mémoire (le pointeur, qui est aussi une variable comme une autre et qui est aussi copiée dans le second cas, il n'y a que des passages de paramètres par copie en C).

A+

[dicovid]

merci c'est gentil d'avoir répondu si vite, je pense avoir compris le fonctionnement des structures, en fait je ne savais pas ou utiliser les pointeurs, maintenant c bon.

merci encore.

[zicos]

Si tu ne déclare pas deux heures différentes au sein de ton main, je ne vois pas comment tu pourrais allouer deus heures différentes. Renseigne toi sur le passage de variable en paramètre dans une fonction.
Pas du tout vérifier les modifs, mais ca doit plutot etre un truc du genre.

[Skyounet]

renseigne toi sur le passage de variable en paramètre dans une fonction.
Pas du tout vérifier les modifs, mais ca doit plutot etre un truc du genre.

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
struct temps
            { int heures;
              int minutes;
              int secondes;
            };
 
entree(temps e)
{
 
printf("entrez heure  minutes  secondes ");
scanf("%d %d %d",&e.heures,&e.minutes,&e.secondes);
}
 
main()
{
temps t1,t2;
// ou plutôt 
 
 
entree(&t1);/*utilisé pour t1*/
entree(&t2);/*utilisé pour t2*/
 
}

Ton code est faux. Tu n'a pas (ou p-e oublié) modifié le prototype de la fonction. Et en plus tu accedes a tes membres de structure comme si c'était une structure normale.