Discussion :

[amargo87]

alors bonsoir, je suis nouveau a la programmation C, et je suis a la recherche d'aide pour parvenir a faire ce program, je n'arrive pas a le commencer, a vrai dire je ne sais pas par ou commencer ni comment.le program que je dois creer doit lire les 3 notes suivantes: intra, final et tps , ainsi que calcule la moyenne pondérée des 2 examens :
moyPond = (intra x 0.20 + final x 0.40) / 0.60
ensuite, vérifie le seuil et ajuste la note globale des travaux si nécessaire (pour imposer un échec)
Si moyPond < 40 ET tps > 50 Alors tps = 50
Et finallememnt, calcule la note globale:
globale = 0.20 x intra + 0.40 x final + 0.40 x tps

je n'ai aucune idee comment commence,
mon program

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
#Include <stdio.h>
 
 main(void)
{ 
const intra, final, tps
float x;
float y;
float z;
scanf("%f", &x);
scanf("%f", &y);
scanf("%f", &z);

et apres? je suis tres debutant je ne comprends pas comment y parvenir, j ai reussit la suite, mais je n'arrive pas a commence ni placer tout cela.Merci d'avance pour votre aide

[Bayard]

Heu ca compile ça ?

Pouvez-vous poster le résultat de la compilation ?

Je doute que sans l'accolade finale, la compilation réussisse.

Par ailleurs "program" s'écrit programme.

[amargo87]

non ca compile pas, pourrier vous me dire comme commencer ce programme svp


Merci bien

[Thierry Chappuis]

En pseudo-code, voilà ce que donne l'algo que tu dois implanter:

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
Procédure CALCULER-MOYENNE()
    Afficher("Entrez la valeur de intra: ")
    intra <- SaisirValeur()
    Afficher("Entrez la valeur de final: ")
    final <- SaisirValeur()
    Afficher("Entrez la valeur de tps: ")
    tps <- SaisirValeur()
 
    moyPond <- (intra * 0.20 + final * 0.40) /0.60
 
    SI moyPond < 40 ET tps > 50 ALORS
        tps <- 50
    FIN SI
    global <- 0.20 * intra + 0.40 * final + 0.40 * tps
    Afficher("La valeur de global est: ")
    AfficherValeur(global)

L'implantation de cet algorithme est aisée si tu possèdes une fonction saisir_flottant() par exemple. scanf() est déconseillé, car trop complexe. Je conseille de te construire un fonction personnalisée. Comme la saisie d'une valeur entrée par l'utilisateur est la seule difficulté de ton problème, on va prendre le temps de le faire bien. Commençons par apprendre à saisir une ligne à partir de la fonction getchar() (voir documentation) dont l'action est de saisir un caractère sur le flux d'entrée standard et de renvoyer le code de ce caractère sous la forme d'un entier de type int. Si je vais un peu vite dans mes explications, tu peux lire cet article qui explique tout avec beaucoup de détails (et bien mieux que moi): http://emmanuel-delahaye.developpez.com/inputs.htm. Ainsi, nous écrivons le code suivant:

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <stdio.h>
 
int saisir_ligne(char tampon[], size_t taille)
{
    /* code d'erreur retourne par la fonction. Vaut 0 si aucune erreur. */
    int err = 0;
 
    /* On verifie la validite des arguments passes a la fonction */
    if (tampon != NULL && taille > 1)
    { /* Les arguments sont valides */
 
        /* declaration des variables */
        int c;
        size_t i = 0;
 
        /* On saisit chaque caractere entre au clavier (a l'aide 
           de c = getchar()) et on fait attention a ne pas depasser 
           la capacité de tampon (i < taille - 1) */ 
        while ((c = getchar()) != '\n' && c != EOF && i < taille - 1)
        {
            tampon[i] = c;
            i++;
        }
        /* On termine la saisie par ajouter le caractere nul en fin 
           de chaine */
        tampon[i] = '\0';
 
        /* Si c est different de '\n' ou de EOF, la saisie s'est terminee 
           alors qu'il reste des caracteres dans le tampon du flux d'entree 
           standard. Il faut NETTOYER TOUT CELA! */
        if (c != '\n' && c != EOF)
        {
            while ((c = getchar()) != '\n' && c != EOF)
            {
                /* Cette boucle ne fait rien d'autre que consommer les 
                   caracteres qui restent sur le flux d'entree standard */
            }
 
            /* AVERTISSEMENT:On signale a l'utilisateur que la saisie 
               a ete tronquee */
            err = -1;
        }
    }
    else
    {
        /* ERREUR: on a passe une valeur qui n'est pas valide en argument
           de la fonction */
        err = 1;
    }
    /* On retourne le code d'erreur */
    return err;
}

J'ai intégré un grand nombre de commentaires dans le code. N'hésite pas à poser des questions si tu ne comprend pas.

Nous pouvons donc maintenant écrire la fonction saisir_flottant() que nous allons utiliser pour implanter notre algorithme. Cette fonction utilisera saisir_ligne() et la fonction strtod() de la bibliothèque standard (voir la documentation). Voici le prototype de notre fonction:

Code :

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

double saisir_flottant(char const *message_err);

Cette fonction renvoie un entier de type double (par exemple, la valeur de intra, final ou tps dans le contexte de ton problème). On peut lui passer en argument le message à afficher en cas d'erreur dans la saisie. Voici comment j'implante cette fonction:

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <stdlib.h>
 
double saisir_flottant(char const *message_err)
{
    int err = 0;
    char tampon[20] = "";
    double d = 0.0;
    char *pend = NULL;
 
    /* On saisit la ligne entree par l'utilisateur */
    do
    {
        err = saisir_ligne(tampon, sizeof tampon);
        /* Si l'entree de l'utilisateur n'a pas ete tronquee, err vaut 0 */
        if (err == 0)
        {
            d = strtod(tampon, &pend);
 
            /* Si l'utilisateur n'a rien entre d'autre qu'un nombre
               flottant, la valeur pointee par pend est le caractere 
               nul */
            if (*pend != '\0')
            {
                /* Erreur: le tampon contient autre chose que le nombre
                   flottant. On affiche le message! */
                if (message_err != NULL)
                {
                    printf("%s ", message_err);
                    fflush(stdout);
                }
                err = 2;
            }
        }
        else
        {
            /* Erreur: la saisie a ee tronquee. On affiche le
               message! */
            if (message_err != NULL)
            {
                printf("%s ", message_err);
                fflush(stdout);
            }
        }
    }
    while (err != 0 || *pend != '\0');
 
    return d;
}

Même principe. Pose des questions si tu ne comprends pas. Comme exercice, tu peux également implanter une fonction saisir_entier() ou saisir_char(). Je rappelle que tu trouveras des explications plus détaillées sur la bonne manière des réaliser des saisies utilisateur sécurisées en C dans l'article suivant (à lire absolument): http://emmanuel-delahaye.developpez.com/inputs.htm. Nous pouvons maintenant réaliser ton programme:

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
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#include <stdio.h>
#include <stdlib.h>
 
int saisir_ligne(char tampon[], size_t taille);
double saisir_flottant(char const *message_err);
 
int main(void)
{
    double intra;
    double final;
    double tps;
    double moy_pond;
    double global;
 
    printf("Entrez la valeur de intra: ");
    fflush(stdout);
    intra = saisir_flottant("Erreur de saisie pour intra! Essayez encore:");
 
    printf("Entrez la valeur de final: ");
    fflush(stdout);
    final = saisir_flottant("Erreur de saisie pour final! Essayez encore:");
 
    /* La suite du code est triviale */
 
    return EXIT_SUCCESS;
}
 
/*
 * Permet de saisir de maniere securisee une ligne entree par l'utilisateur 
 * via le flux d'entree standard.
 */
int saisir_ligne(char tampon[], size_t taille)
{
    /* code d'erreur retourne par la fonction. Vaut 0 si aucune erreur. */
    int err = 0;
 
    if (tampon != NULL && taille > 1)
    {
        /* declaration des variables */
        int c;
        size_t i = 0;
 
        /* On saisit chaque caractere entre au clavier (a l'aide
           de c = getchar()) et on fait attention a ne pas depasser 
           la capacité de tampon (i < taille - 1) */
        while ((c = getchar()) != '\n' && c != EOF && i < taille - 1)
        {
            tampon[i] = c;
            i++;
        }
        /* On termine la saisie par ajouter le caractere nul en fin
           de chaine */
        tampon[i] = '\0';
 
        /* Si c est different de '\n' ou de EOF, la saisie s'est terminee
           alors qu'il reste des caracteres dans le tampon du flux d'entree 
           standard. Il faut NETTOYER TOUT CELA! */
        if (c != '\n' && c != EOF)
        {
            while ((c = getchar()) != '\n' && c != EOF)
            {
                /* Cette boucle ne fait rien d'autre que consommer les
                   caracteres qui restent sur le flux d'entree standard */
            }
 
            /* AVERTISSEMENT:On signale a l'utilisateur que la saisie
               a ete tronquee */
            err = -1;
        }
    }
    else
    {
        /* ERREUR: on a passe une valeur qui n'est pas valide en argument
           de la fonction */
        err = 1;
    }
 
    return err;
}
 
/*
 * Cette fonction permet de saisir de maniere securisee un nombre a 
 * virgule flottante a partir du flux d'entree standard.
 */
double saisir_flottant(char const *message_err)
{
    int err = 0;
    char tampon[20] = "";
    double d = 0.0;
    char *pend = NULL;
 
    /* On saisit la ligne entree par l'utilisateur */
    do
    {
        err = saisir_ligne(tampon, sizeof tampon);
        /* Si l'entree de l'utilisateur n'a pas ete tronquee, err vaut 0 */
        if (err == 0)
        {
            d = strtod(tampon, &pend);
 
            /* Si l'utilisateur n'a rien entré d'autre qu'un nombre
               flottant, la valeur pointee par pend est le caractere 
               nul */
            if (*pend != '\0')
            {
                /* Erreur: le tampon contient autre chose que le nombre
                   flottant. On affiche le message! */
                if (message_err != NULL)
                {
                    printf("%s ", message_err);
                    fflush(stdout);
                }
                err = 2;
            }
        }
        else
        {
            /* Erreur: la saisie a ee tronquee. On affiche le
               message! */
            if (message_err != NULL)
            {
                printf("%s ", message_err);
                fflush(stdout);
            }
        }
    }
    while (err != 0 || *pend != '\0');
 
    return d;
}

Thierry

[allan02390]

Bonjour, je n'ai pas trop compris ce que tu voulais faire, mais j'ai suivis l'algo que tu avais mis :

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
29
30
31
32
33
34
35
36
 
#include <stdio.h>
#include <conio.h>
 
void main ()
{
 
             // *********Declaration et initialisation de tes variables*****
 
             float intra=O, final=0, tps=0;
	float x=0, y=0, z=0;
	float moyenne=0, globale=0;
 
	// ********Saisies de tes données********
 
             printf("Entrez votre note Intra\n");//affiche sur l'ecran
	scanf("%f", &intra);//affecte la valeur saisie dans la variable
 
	printf("Entrez votre note final\n");
	scanf("%f", &final);
 
	printf("Entrez votre note tps\n");
	scanf("%f", &tps);
 
 
moyenne = ((intra * 0,20) + (final * 0,40)) / 0,60;
 
if ((moyenne <40) && (tps > 50)) tps = 50; // Ta condition que tu as cité
 
globale = (0,20 * intra) + (0,40 * final) + (0,40 *tps) ;
 
	printf("La note globale est : %f", globale);
 
getch();// Attente d'une touche pour fermer le programme
 
}

Je n'ai pas essayer le code, a toi de l'essayer et de modifier les erreurs
a bientot

[Médinoc]

Quelques remarques sur le code de allan02390 :

1. main() retourne un int. Toujours.
2. Oubli du \n dans le dernier printf().
3. getch() n'est pas une fonction standard et est inutile à moins que l'Environnement de Développement (EDI) utilisé soit Dev-C++ (à cause d'un bug de Dev-C++). Et même si c'est Dev-C++, system("pause") est mieux qu'un appel à getch().
4. Une fois l'appel à getch() supprimé, l'on peut aussi supprimer l'inclusion de <conio.h> qui n'est pas standard non plus.

[allan02390]

J'ai fais le code en live comme sa, je sais bien que normalement le programme commence par

Code :

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

1
2
3
4
5
 
int main(int argc, char* argv[])
{
	return 0;
}

et retourne un entier

Et le dernier printf pour le \n j'en vois pas l'utilité car apres on affiche plus rien donc pas besoin d'envoyer les caracteres oxOD et oxOA.

Pour le getch() j'aurais du préciser que c'est juste pour lui voir l'affichage a l'écran mais bon il est pas conseiller d'utiliser un getch().
Merci

[john stedd]

J'ai fais le code en live comme sa, je sais bien que normalement le programme commence par...

le code que tu proposes "en live" ne peut pas, il me semble, aider un débutant puisqu'il est bourré d'erreurs et de warnings à la compilation. il vaut mieux donner des indications ou des corrections qui seront bien plus utiles à la personne qui pose la question...

[|PaRa-BoL]

besoin d'envoyer les caracteres oxOD et oxOA.

Tu voulais peux être dire 0x0A ?

[Emmanuel Delahaye]

J'ai fais le code en live comme sa, je sais bien que normalement le programme commence par

Si tu sais le faire, écrit le code correct directement. On a pas que ça à faire de corriger les fautes des intervenants...

[allan02390]

oui je voulais dire 0x0D et 0x0A (le \n )

[DaZumba]

oui je voulais dire 0x0D et 0x0A (le \n )

Sous Windows uniquement.

[|PaRa-BoL]

oui je voulais dire 0x0D et 0x0A (le \n )

Non \n = 0x0A uniquement

L'autre est le \r (le tout faisant un CRLF => Uniquement Windows)

[Emmanuel Delahaye]

Non \n = 0x0A uniquement

L'autre est le \r (le tout faisant un CRLF => Uniquement Windows)

Tout cela est faux.

• En mode binaire, '\n' et '\r' sont respectivement les caractères de contrôle LF (Line Feed) et CR (Carriage Return).
• En mode texte sous Windows, le caractère '\n' est codé CRLF (et inversement).
• En mode texte sous Mac OS (<> X), le caractère '\n' est codé CR (et inversement).

http://emmanuel-delahaye.developpez....s.htm#fichiers

[amargo87]

est ce qu'il y a un autre moyen de debuter ce program, autre que celle que moi j'ai choisi qui sera beaucoup plus simple, que celle expliquer par Thierry?
il me parrait comme un travail trop complexe pour mon niveau