Commencer un programme

Version imprimable

11/10/2007, 06h17
amargo87

Commencer un programme
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:

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
11/10/2007, 07h33
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.
11/10/2007, 07h39
amargo87

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

Merci bien

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

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
 
#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

11/10/2007, 09h12
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.
11/10/2007, 09h27
allan02390
J'ai fais le code en live comme sa, je sais bien que normalement le programme commence par
Code:

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
11/10/2007, 09h41
john stedd

Citation:

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...
11/10/2007, 09h43
|PaRa-BoL

Citation:

besoin d'envoyer les caracteres oxOD et oxOA.

Tu voulais peux être dire 0x0A ?
11/10/2007, 09h48
allan02390

oui je voulais dire 0x0D et 0x0A (le \n )
11/10/2007, 10h08
DaZumba

Citation:

Envoyé par allan02390

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

Sous Windows uniquement.
11/10/2007, 10h13
|PaRa-BoL

Citation:

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)

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

Code:

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:

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:

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:

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:

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

11/10/2007, 13h31
Emmanuel Delahaye

Citation:

Envoyé par allan02390

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...
11/10/2007, 13h34
Emmanuel Delahaye
Citation:

Envoyé par |PaRa-BoL

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
11/10/2007, 13h57
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

Je ne vois pas de solution plus courte que ça:

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
#include <stdio.h>
#include <stdlib.h>
 
void clean(void);
double get_double(char const *message);
 
int main(void)
{
    double intra;
    double final;
    double tps;
    double moy_pond;
    double global;
 
    intra = get_double("Entrez la valeur de intra:");
    final = get_double("Entrez la valeur de final:");
    tps = get_double("Entrez la valeur de tps:");
 
    moy_pond = (intra * 0.20 + final * 0.40) / 0.60;
 
    if (moy_pond < 40 && tps > 50)
    {
        tps = 50;
    }
 
    global = 0.20 * intra + 0.40 * final + 0.40 * tps;
 
    printf("La note global vaut: %.2f\n", global);
 
    return EXIT_SUCCESS;
}
 
void clean(void)
{
    int c;
    while ((c = getchar()) != '\n' && c != EOF)
    {
    }
}
 
double get_double(char const *message)
{
    int rv;
    double d;
 
    do
    {
        if (message != NULL)
        {
            printf("%s ", message);
            fflush(stdout);
        }
        rv = scanf("%lf", &d);
        clean();
    }
    while (rv != 1);
 
    return d;
}

Thierry