Tweet
Interface utilisateur console
Imaginons que vous vouliez calculer votre moyenne générale, vous pourriez mettre les moyennes de chacune de vos matières dans le programme. Cela implique que vous rentriez en dur (dans le code) toutes vos moyennes avec les étapes suivantes:
- Exécuter code::blocks
- Éditer votre programme
- Entrer vos moyennes
Code:float moyennes[] = {12.5, 15, 7, 9.5, 18, 10, 5.5}; - Exécuter le programme
T'as pas plus simple Fred, car rien que lire toutes ces étapes ça me fatigue déjà ?
Euh, attendez que je réfléchisse... Si c'est possible, regardez plus bas
- Exécuter votre programe
- Entrer vos moyennes
Mieux non?
Ok c'est mieux, mais on fait comment ? Nous allons voir deux fonctions faîtes pour cela
Scanf mon sauveur !
Grâce à scanf, vous pourrez récupérer la valeur inscrite par l'utilisateur dans la console pour l'enregistrer dans une variable...
C'est cool ça, mais je connais pas scanf ! Eh bien on va analyser son prototype
int scanf ( const char * format, ... );
Que remarque-t-on ? Cette fonction
- retourne un entier (il permettra de vérifier que la fonction s'est exécutée correctement)
- prend plusieurs paramètres, une chaîne de caractère format ("%d, %s, %f, ...) et ... (autant de paramètres que l'on souhaite)
Les ... on verra plus tard, pour l'instant on considérera que scanf prend une chaîne de formatage et une variable dont le type correspond au formatage
ok, ok, d'accord ! Bon je met quoi comme type d'argument, que dit la documentation ?
Envoyé par documentation
un pointeur est une variable contenant une adresse. Pour avoir cette adresse nous aurons besoin de l'opérateur &, d'ailleurs c'est indiqué dans la partie anglaise ci-dessus...Exemple d'utilisation:
Code:
#include <stdio.h>
int main(void)
{
int retour;
int valeur; /* déclaration de mes variables retour et valeur */
printf("Entrer un entier: ");
retour = scanf("%d", &valeur); /* demande entier à utilisateur */
if (retour == 1) /* on vérifie qu'on a bien 1 conversion qui s'est passé */
{
printf("\nta valeur entrée est %d\n", valeur); /* on affiche valeur */
}
return 0;
}
- un entier (exemple 12)
- un flottant (exemple 12.5)
- un caractère (exemple a)
- une chaîne de caractère (exemple abc)
que remarquez-vous ?
Bien, mais si je reviens à mon problème, j'ai plusieurs valeurs à entrer, je fais comment ?
Avec des boucles, non?
Voici un exemple:
Code:
#include <stdio.h>
int main(void)
{
int i;
int retour;
int mesValeurs[3];
int valeur; /* déclaration de mes variables retour et valeur */
for (i=0; i<3; i++) /* 3 valeurs à entrer */
{
printf("Entrer l'entier n°%d: ", i+1);
retour = scanf("%d", &valeur); /* demande entier à utilisateur */
if (retour == 1) /* on vérifie qu'on a bien 1 conversion qui s'est passé */
{
mesValeurs[i] = valeur; /* enregistrement de valeur n°i dans mesValeurs[i] */
}
else /* si erreur de conversion, scanf s'est mal passé */
{
puts("\nErreur de conversion");
return -1;
}
}
for (i=0; i<3; i++) /* affichage des valeurs de mon tableau */
{
printf("\nvaleur n°%d vaut %d\n", i+1, mesValeurs[i]);
}
return 0;
}
Si on veut faire cela avec des flottants, on fait comment ?
On change de formatage en remplaçant %d par %f, vu dans la partie fonctions d'affichage
ok, d'ac, c'est parti, refaire le même programme en remplaçant %d par %f au bon endroit et vérifier que cela fonctionne tout aussi bien qu'avec des entiers...
fgets mon sauveur
Comme scanf, fgets nous permettra de récupérer la valeur entrer par l'utilisateur et l'enregistrer dans une variable, pour là traiter par la suite.
Analysons cette fonction à l'aide de son prototype
char * fgets ( char * str, int num, FILE * stream );
Ouffff, balèze celle-là !
Non paniquez pas, je vous explique, la fonction fgets
- retourne une variable (pointeur) contenant une adresse de type char (permettra de vérifier que la fonction s'est correctement exécutée)
En gros on va vérifier que l'enregistrement de la valeur utilisateur est bien dans la variable str, en testant si on a une valeur NULL en retour de fonctionEnvoyé par documentation - prend comme 1er paramètre l'adresse (pointeur) du 1er caractère de la variable str
- prend comme 2ème paramètre un entier représentant la taille de la chaîne str
- prend comme 3ème paramètre un type FILE (on connaît pas, chez nous ça sera toujours stdin (console))
exemple d'utilisation:
Code:
#include <stdio.h>
int main(void)
{
char result[100]; /* déclaration variable contenant la valeur utilisateur, 99 caractères maxi + 1 caractère fin de chaîne '\0' fait 100 caractères */
char *p; /* déclaration variable contenant valeur de retour pour fgets */
printf("Entrer votre nom: ");
p = fgets(result, 100, stdin); /* enregistrer valeur console dans result */
if (p != NULL) /* Si ça s'est bien passé pour fgets */
{
printf("\nVotre nom est %s\n", result); /* Afficher résultat */
}
return 0;
}
Après cela, j'aimerais entrer plusieurs chaînes de caractères, et les afficher ensuite...
Ah... alors attention, on le fait, mais on le fait bien !
Une chaîne de caractères est un tableau de caractères en C
Un tableau de chaînes de caractères est donc un tableau de tableaux de caractères (pas de fautes d'orthographe, tableau avec un x, il y en a plusieurs)
On va limiter le travail ! On veut entrer 3 chaînes de caractères avec 99 caractères maxi
Code:
#include <stdio.h>
int main(void)
{
int i;
char result[3][100]; /* variable contenant 3 chaînes de 100 caractères ('\0' compris) */
char *p; /* valeur de retour pour fgets */
for (i=0; i<3; i++)
{
printf("Entrer le nom n°%d: ", i+1);
p = fgets(result[i], 100, stdin); /* enregistrer valeur n°i console dans result */
if (p == NULL) /* Si ça s'est mal passé pour fgets */
{
return -1; /* on sort du programme avec code -1 */
}
}
for (i=0; i<3; i++)
{
printf("\nchaine n°1: %s", result[i]); /* affichage de chaine n°i */
}
return 0;
}
EXERCICES
Exercice n°1:
Complétez le code ci-dessous
Code:
#include <stdio.h>
#include <string.h>
int compteur(char *chaine);
int main(void)
{
int i; /* déclaration index, nombre de demandes utilisateur */
char *p; /* déclaration retour de fgets */
char maChaine[100]; /* déclaration variable contenant valeur console par utilisateur */
for (i=0; i<5; i++)
{
printf("\nEntrer la chaine pour compter son nombre de voyelles: ");
/* à compléter, utilisation de fgets */
if (p != NULL)
{
p = strchr(maChaine, '\n'); /* pas de préoccuper */
if (p != NULL) /* pas se préoccuper */
*p = '\0'; /* pas se préoccuper */
printf("\nma chaine %s contient %d voyelles\n", maChaine, compteur(maChaine)); /* affichage du résultat */
}
}
return 0;
}
int compteur(char *chaine)
{
/* fonction permettant de compter les voyelles */
int i; /* déclaration index pour lire caractère par caractère chaine */
int j; /* déclaration index pour lire caractère par caractère voyelles */
int resultat = 0; /* valeur contenant le nombre de voyelles dans valeur de la variable chaine */
char voyelles[] = {'a', 'e', 'i', 'o', 'u', '\0'}; /* déclaration de toutes les voyelles dans tableau voyelles */
for (i=0; chaine[i]!='\0'; i++) /* pour chaque caractère de la variable chaine */
{
for (j=0; voyelles[j]!='\0'; j++) /* pour chaque caractère du tableau voyelles */
{
/* compléter */
}
}
return resultat;
}
Écrire la suite du code aux endroits indiqués par le commentaire /* à compléter */
Exercice n°2:
Compléter le code ci-dessous
Code:
#include <stdio.h>
float moyenne(float *moyennes, int taille);
int main(void)
{
int i; /* index nombre de demandes pour chaque matière */
int retour; /* déclaration variable valeur de retour de scanf */
float moy; /* déclaration variable contenant la moyenne de chaque matière */
float mesMoyennes[4]; /* tableau contenant toutes les moyennes */
const char matieres[][50] = {
"Français",
"Mathématiques",
"Physiques",
"Anglais"
}; /* tableau des matières */
for (i=0; i<4; i++)
{
printf("Entrer la moyenne pour la matière %s: ", matieres[i]);
/* à compléter - utilisation de scanf, attention au type de formatage */
if (retour == 1) /* si fonction scanf se passe bien */
{
/* à compléter - affecter valeurs dans tableau mesMoyennes */
}
}
for (i=0; i<4; i++)
{
printf("Moyenne de %s: %.1f\n", matieres[i], mesMoyennes[i]); /* affichage de chaque moyenne */
}
printf("\nMa moyenne est de: %.2f\n", moyenne(mesMoyennes, 4)); /* affichage moyenne générale */
return 0;
}
float moyenne(float *moyennes, int taille)
{
float somme = 0; /* déclaration variable contenant valeur somme du tableau moyennes */
int i; /* index gérant taille tableau moyennes */
for (i=0; i<taille; i++)
{
/* à compléter, calcul de somme du tableau moyennes */
}
return somme/taille; /* retourne la moyenne */
}
Compléter les endroits où il est indiqué le commentaire /* à compléter ... */
Merci de m'avoir lu et à bientôt pour le prochain cours
Commentaire