La
librairie standard
Introduction:
Dans
ce chapitre, on ne va pas entrer dans les détails car ce
sont des choses que nous allons voir ensemble au fur et à
mesure. Mais vous devez quand même comprendre qu’on
ne va pas perdre le temps d’expliquer à nouveau ce
qu’on verra dans ce chapitre.
Dans le chapitre précèdent, on a vu
qu’un programme commence
par la fonction « main ».
Bon depuis maintenant vous devez mettre en tête que ceci
n’est pas faux mais il est très
recommandé, même obligatoire de fournir un
prototype à chaque fonction utilisée car beaucoup
de compilateurs n’arrivent pas effectuer leurs taches si les
fonction ne sont pas utilisés avec leur prototypes.
C’est ce qui fait que avant d’attaquer la fonction
« main », nous allons commencer
par autre chose:la librairie standard (stdio.h, stdlib.h,...).
Nous allons la placer juste à coté de
directive #include qui permet
d'incorporer dans le fichier source le texte figurant dans un autre
fichier.
Exemple : #include
<stdio.h>
Je répète qu’il
est donc nécessaire de commencer par ces types de directives
préprocesseur avec la
bibliotheque illustrés
dans l’exemple ci-dessous et ci-dessus, selon
les fonctions utilisées :
Exemples des directives de
préprocesseur :
#include<stdio.h>
#include<math.h>
-
Entrées-sorties
<stdio.h>:
Pour
utiliser les fonctions ci-dessous, nous avons besoins
d’utiliser stdio.h.
Pour impression
et lecture de caractères
| fonction |
prototype |
action |
| fgetc |
int
fgetc(FILE *stream) |
lecture d'un
caractère depuis un fichier |
| fputc |
int
fputc(int c, FILE *stream) |
écriture
d'un caractère sur un fichier |
| getc |
int
getc(FILE *stream) |
équivalent
de fgetc mais implémenté
par une macro |
| putc |
int
putc(int c, FILE *stream) |
équivalent
de fputc mais implémenté
par une macro |
| getchar |
int
getchar(void) |
lecture d'un
caractère depuis l'entrée standard |
| putchar |
int
putchar(int c) |
écriture
d'un caractère sur la sortie standard |
| fgets |
char
*fgets(char *s, FILE *stream) |
lecture d'une
chaîne de caractères depuis un fichier |
| fputs |
int
*fputs(char *s, FILE *stream) |
écriture
d'une chaîne de caractères sur un fichier |
| gets |
char
*gets(char *s) |
lecture d'une
chaîne de caractères sur l'entrée
standard |
| puts |
int
*puts(char *s) |
écriture
d'une chaîne de caractères sur la sortie standard |
Pour les entrées et sorties formatées:
| fonction |
prototype |
action |
| fprintf |
int
fprintf(FILE *stream, char *format, ...) |
écriture
sur un fichier |
| fscanf |
int
fscanf(FILE *stream, char *format, ...) |
lecture depuis
un fichier |
| printf |
int
printf(char *format, ...) |
écriture
sur la sortie standard |
| scanf |
int
scanf(char *format, ...) |
lecture depuis
l'entrée standard |
| sprintf |
int
sprintf(char *s, char *format, ...) |
écriture
dans la chaîne de caractères s |
| sscanf |
int
sscanf(char *s, char *format, ...) |
lecture depuis
la chaîne de caractères s |
Pour manipuler les fichiers
| fonction |
action |
| fopen |
ouverture d'un
fichier |
| fclose |
fermeture d'un
fichier |
| fflush |
écriture
des buffers en mémoire dans le fichier |
Ce ne sont pas
seulement ceux qui sont dans ces tableaux mais
on aura toujours le temps de les voir.
Ceux qui nous intéressent pour le moment, ce sont les
entrées/sorties permettant d’afficher des
informations sur l’écran, de
mettre en forme les messages envoyés vers les
écrans et de lire les données entrées
au clavier.
Je vais consacrer mon temps à vous les
expliquer et les illustrer par des exemples. Profitez cette occasion et
essayez de bien comprendre car il
s’agit de la base de notre deuxième TP.
La fonction printf:
La fonction printf nous permet
d’afficher des
informations sur l’écran.
1er cas:
Syntaxe : printf(" texte à afficher
");
ex: printf(" Quel bon
site!");
Ouvrez votre IDE de C/C++
saisissez l’exemple puis compilez et
exécutez, vous verrez que ça vous affichera Quel
bon site.
Je suppose que vous savez déjà comment
compiler et exécuter un
programme et que vous savez comment structurer un programme si non
retourne aux chapitre précèdent avant de
continuer ce que nous venons de dire.
Bon je vous aide sur la structure
code c:
#include<stdio.h>
main()
{
printf(" Quel bon
site!");
} |
Compiler et exécuter pour
voirr, ça vous affichera "Quel
bon site"!.
Bon une console(fenêtre) s'ouvrira et se fermera en
un clin d’œil et vous
n’arriverez pas à voir que ça afficher
ce que nous vous voulons.
Bon nous allons faire de telle sorte que notre
fenêtre restera en pause jusqu'à ce que nous la
fermions nous même.Pour ce la nous devons faire appelle
à une autre
bibliothèque (librairie) qui est : stdlib.h
Et pourquoi stdlib.h ?
C’est juste parce que pour résoudre ce
problème, nous allons utiliser : system(" pause")
qui est une fonction appartenant à stdlib.
exemple
code
c:
#include<stdlib.h>
main()
{
system("pause");
}
|
Si vous faites copier coller, vous
verrez que cette fenêtre s’ouvrira et
elle attendra que vous vous la
fermiez.
Souvenez
vous qu’on est toujours sur la
bibliothèque stdio mais si nous avons introduit le stdlib.h c’est
juste pour résoudre notre petit problème. A la
fin de ce chapitre nous allons voir en bref la bibliothèque
stdlib.
Maintenant vous
pouvez saisir ce code et voir ce qui va se passer.
code
c:
#include<stdio.h>
#include<stdlib.h>
main()
{
printf(" Quel bon
site!");
system("pause");
}
|
Vous
allez voir cette fenêtre s’ouvrir.
" Ah j’arrive à faire des choses
pareilles ".lol.
Bon je sais que la plus part de vous se
disent que c’est très vilain ce fenêtre
mais ne vous en faites pas car il y
aura le moment ou nous allons réaliser nos propre
fenêtre. Et ça sera très jolie comme
nous le voudrons. N’oublie pas que ce
fenêtre n’est pas à nous, il a
appartient au système d’exploitation que nous
utilisons. Donc selon notre niveau, nous n’avons pas le
choix, nous devons l’accepter.
Quelque
chose qui rend aussi plus vilain ce fenêtre :
« appuyez sur une touche pour
continuer ».
Vous voyez que cette phrase
est sur la même ligne que la phrase que nous avons
programmée. Bon nous pouvons l’afficher sur la
ligne suivante juste en ajoutant: \n. a la fin
de notre phrase que nous voulons afficher.
voici le code:
#include<stdio.h>
#include<stdlib.h>
main()
{
printf(" Quel bon
site!\n");
system("pause");
}
|
pres avoir
executer, vous allez voir ceci:
**Une petite astuce:les ordres de Contrôles
ils permettent de controler l'emplacement final du message en
deplaçant le curseur.
| ordre |
signification |
| \a |
sonerie
( alarm) |
| \b |
retour
en arrière ( back return) |
| \n |
retour
a ligne |
| \t |
tabulation
horizontale |
| \\ |
backslash( antislash) |
| \" |
guillemet |
| \r |
retour
chariot |
| \v |
tabulation
verticale. |
Pour mieux comprendre la
signifification de ce tableau, il suffit de retourner sur le code
précèdant et remplacer a chaque fois "\n" par
l'un des controles presentés sur notre tableau.
2ème
cas:
syntaxe: printf ("chaine
format",variable1,variable2,...);
exemple: printf("ton age est %d",x);
la fonction scanf:
Avant d’attaquer la
fonction scanf, nous allons les spécifications de conversion.
| conversion |
signification
|
types
convertis |
| %c |
un
seul caractere |
char
|
| %d |
entier
decimal signé |
int,
short |
| %ld |
entier
decimal long |
long |
| %f |
nombre
à virgule flottante |
float,double |
| %lf |
nombre
decimal flottante long |
float,
double |
| %s |
chaine
de caractere |
(tableaux)
char |
| %u |
entier
decimal non signé |
unsigned int,
unsigned short |
| %ul |
entier
decimal non signé long |
unsigned
long |
Vous pouvez vous demander cette
question ; pourquoi nous avons commencé les
spécifications de conversion ?
C’est juste parce que pour
utiliser scanf, nous avons besoin de ça.
Attaquons notre fameuse fonction
scanf.
La
fonction scanf permet de lire les données entrées
au clavier en fonctions du format spécifié et les
attribue à une ou plusieurs variables du progrmme.
Son syntaxe :
#include<stdio.h>
Scanf(chaine format[,argument,…] ;
Exemple :
#include<stdio.h>
Scanf("lf",&prix d'achat);
je sais que vous avez un peu de
difficulté à comprendre c’est pourquoi
j’aime rendre très explicite ce que je vous dis.
Allez réveillez vous voici
le moment de comprendre. L’exemple
suivant va vous permettre de bien
comprendre.
exemple:
nous allons demander à quelqu'un de saisir 2 nombres : l'un
entier décimal long et l'autre un nombre à
virgule flottant.
Une fois que la personne saisira les
nombres. Nous allons les afficher sur l’écran.
Je ne vous demande pas de beaucoup
réfléchir sur ça car il
s’agit d’un exemple qui va vous permettre de
comprendre le but de la fonction scanf.
Voici l’exemple
commenté :
Code C/C++ :
|
#include<stdio.h>
#include<stdlib.h>
main()
{ long int x;//declaration
de x étant un entier long
double y;//
declaration de y etant un nombre a virgule
printf("entrer un nombre entier\n");// on demnde à
l'utilisateur de sair un nombre entier
scanf("%ld",&x);//
ici on va lire et retenir le nombre entier saisi
printf("enter un nombre a nombre a virgule\n");
scanf("%f",&y);//ici
on va lire et retenir le nombre à virgule saisi
system("pause");//
retenir l'ecran
return 0; //
retourner à 0
}
|
les phrases en bleu sont les commentaires,elles sont facultatives. je
les ecris pour que que vous puissiez mieux comprendre.
voici le resultat de ce code:
Essayons d’effacer tous nos
scanf et voir ce qui ce va se passer.
Voici le code C/C++
#include<stdio.h>
#include<stdlib.h>
main()
{ long int x;
double y;
printf("entrer un nombre entier\n");
printf("enter un nombre a nombre a virgule\n");
system("pause");
return 0;
} |
voici le resultat du
fichier executable.
Regardez le résultat. il
nous a dit juste d'entrer les nombres mais nous ne pouvons pas
réelement entrer les nombres. c'est juste parce qu'il y pas
les fonctions scanf. j'espere que vous avez bien compris maintenant .
Note bien: il
faut eviter d'utiliser des lettres accentuées ou des mots
propres à C/C++ dans votre programme.
la fonction puts
Comme la fonction printf ;
la fonctions puts permet d’afficher du texte à
l’écran mais pas des variables. Elle peut donc
prendre en compte les ordres de contrôle mais pas les
spécifications de conversion.
Syntaxe :
#include<stdio.h>
Puts (chaîne),
exemlple:
voici le codeC/C++
#include<stdio.h>
#include<stdlib.h>
main()
{
puts(" je suis ravi
de connaitre ce site qui donne des cours bien commentes!\n");
system("pause");
}
|
voici le résultat du
fichier executable :
Manipulation
de caractères <ctype.h>
Ici nous avons des fonctions qui testent
une propriété du caractère
passé en paramètre. Elles renvoient la
valeur 1 si le caractère vérifie la
propriété et 0 dans le cas contraire.
Leur prototype est : int fonction (char c)
| fonction |
renvoie 1
si le caractère est |
| isalnum |
une lettre
ou un chiffre |
| isalpha |
une lettre |
| iscntrl |
un
caractère de commande |
| isdigit |
un chiffre
décimal |
| isgraph |
un
caractère imprimable ou le blanc |
| islower |
une lettre
minuscule |
| isprint |
un
caractère imprimable (pas le blanc) |
| ispunct |
un
caractère imprimable qui n'est ni une lettre ni un chiffre |
| isspace |
un blanc |
| isupper |
une lettre
majuscule |
| isxdigit |
un chiffre
hexadécimal |
ces deux fonctions assurent la conversion entre lettres minuscules et
lettres majuscules :
| fonction |
prototype |
action |
| tolower |
int
tolower(int c) |
convertit c
en minuscule si c'est une lettre majuscule, retourne c
sinon. |
| toupper |
int
toupper(int c) |
convertit c
en majuscule si c'est une lettre minuscule, retourne c
sinon. |
Manipulation de chaînes de
caractères <string.h>
| fonction |
prototype |
action |
| strcpy |
char
*strcpy(char *ch1, char *ch2) |
copie la
chaîne ch2 dans la chaîne ch1 ;
retourne ch1. |
| strncpy |
char
*strcpy(char *ch1, char *ch2, int n) |
copie n
caractères de la chaîne ch2
dans la chaîne ch1 ; retourne ch1. |
| strcat |
char
*strcat(char *ch1, char *ch2) |
copie la
chaîne ch2 à la fin de la
chaîne ch1 ; retourne ch1. |
| strncat |
char
*strncat(char *ch1, char *ch2, int n) |
copie n
caractères de la chaîne ch2
à la fin de la chaîne ch1 ;
retourne ch1. |
| strcmp |
int
strcmp(char *ch1, char *ch2) |
compare ch1
et ch2 pour l'ordre lexicographique ;
retourne une valeur négative si ch1
est inférieure à ch2, une
valeur positive si ch1 est supérieure
à ch2, 0 si elles sont identiques. |
| strncmp |
int
strcmp(char *ch1, char *ch2, int n) |
compare les n
premiers caractères de ch1 et ch2. |
| strchr |
char
*strchr(char *chaine, char c) |
retourne un
pointeur sur la première occurence de c
dans chaine, et NULL si c
n'y figure pas. |
| strrchr |
char
*strchr(char *chaine, char c) |
retourne un
pointeur sur la dernière occurence de c
dans chaine, et NULL si c
n'y figure pas. |
| strstr |
char
*strchr(char *ch1, char *ch2) |
retourne un
pointeur sur la première occurence de ch2
dans ch1, et NULL si ch2
n'y figure pas. |
| strlen |
int
strlen(char *chaine) |
retourne la
longueur de chaine. |
Fonctions mathématiques <math.h>
Le résultat et les paramètres de toutes ces
fonctions sont de type double. Si les
paramètres effectifs sont de type float,
ils seront convertis en double par le
compilateur.
| fonction |
action |
| acos |
arc cosinus |
| asin |
arc sinus |
| atan |
arc tangente |
| cos |
cosinus |
| sin |
sinus |
| tan |
tangente |
| cosh |
cosinus
hyperbolique |
| sinh |
cosinus
hyperbolique |
| tanh |
tangente
hyperbolique |
| exp |
exponentielle |
| log |
logarithme
népérien |
| log10 |
logarithme
en base 10 |
| pow |
puissance |
| sqrt |
racine
carrée |
| fabs |
valeur
absolue |
| fmod |
reste de la
division |
| ceil |
partie
entière supérieure |
| floor |
partie
entière inférieure |
Utilitaires divers <stdlib.h>
Allocation dynamique
| fonction |
action |
| calloc |
allocation
dynamique et initialisation à zéro. |
| malloc |
allocation
dynamique |
| realloc |
modifie la
taille d'une zone préalablement allouée par calloc
ou malloc. |
| free |
libère
une zone mémoire |
Conversion de chaînes
de caractères en nombres
Les fonctions suivantes permettent de convertir une chaîne de
caractères en un nombre.
| fonction |
prototype |
action |
| atof |
double
atof(char *chaine) |
convertit chaine
en un double |
| atoi |
int
atoi(char *chaine) |
convertit chaine
en un int |
| atol |
long
atol(char *chaine) |
convertit chaine
en un long int |
Génération
de nombres pseudo-aléatoires
La fonction rand fournit un nombre entier
pseudo-aléatoire dans l'intervalle [0,RAND_MAX],
où RAND_MAX est une constante
prédéfinie au moins égale à
215-1.
L'aléa fournit par la fonction rand
n'est toutefois pas de très bonne qualité.
La valeur retournée par rand
dépend de l'initialisation (germe) du
générateur. Cette dernière est
égale à 1 par défaut mais
elle peut être modifiée à l'aide de la
fonction srand.
| fonction |
prototype |
action |
| rand |
int
rand(void) |
fournit un
nombre entier pseudo-aléatoire |
| srand |
void
srand(unsigned int germe) |
modifie la
valeur de l'initialisation du générateur
pseudo-aléatoire utilisé par rand.
|
Arithmétique sur
les entiers
| fonction |
prototype |
action |
| abs |
int
abs(int n) |
valeur absolue
d'un entier |
| labs |
long
labs(long n) |
valeur absolue
d'un long int |
| div |
div_t
div(int a, int b) |
quotient et
reste de la division euclidienne de a par b.
Les résultats sont stockés dans les champs quot
et rem (de type int) d'une
structure de type div_t. |
| ldiv |
ldiv_t
ldiv(long a, long b) |
quotient et
reste de la division euclidienne de a par b.
Les résultats sont stockés dans les champs quot
et rem (de type long int)
d'une structure de type ldiv_t. |
Recherche et tri
Les fonctions qsort et bsearch
permettent respectivement de trier un tableau, et de rechercher un
élément dans un tableau
déjà trié.
Communication
avec l'environnement
| fonction |
prototype |
action |
| abort |
void
abort(void) |
terminaison
anormale du programme |
| exit |
void
exit(int etat) |
terminaison du
programme ; rend le contrôle au système
en lui fournissant la valeur etat (la
valeur 0 est considérée comme une fin
normale). |
| system |
int
system(char *s) |
exécution
de la commande système définie par la
chaîne de caractères s. |
Date
et heure <time.h>
tous ces fonctions permettent d'obtenir la date et l'heure.
Le temps est représenté par des objets de type time_t
ou clock_t, lesquels correspondent
généralement à des int
ou à des long int.
| fonction |
prototype |
action |
| time |
time_t
time(time_t *tp) |
retourne le
nombre de secondes écoulées depuis le 1er
janvier 1970, 0 heures G.M.T. La valeur retournée est
assignée à *tp. |
| difftime |
double
difftime(time_t t1, time_t t2) |
retourne la
différence t1 - t2 en secondes. |
| ctime |
char
*ctime(time_t *tp) |
convertit le
temps système *tp en une
chaîne de caractères explicitant la date et
l'heure sous un format prédéterminé. |
| clock |
clock_t
clock(void) |
retourne le
temps CPU en microsecondes utilisé depuis le dernier appel
à clock. |
Chapitre
terminé ! Allez au travail pour notre
deuxième TP.
Ce qu’on va essayer de
faire, c’est d’écrire un programme qui
nous permettra d’afficher quelque chose sur
l’écran. Je suis convaincu que ce n’est
pas quelque chose qui devrait vous poser des problèmes si
vous avez bien compris ce chapitre. Un exercice de rien du tout. Lol.
Notre but est de saisir le programme
qui a réalisé ce fichier exécutable:
Il faut respecter les sauts
des lignes
Avant le premier affichage, on a sauté une ligne. Le 2ème
saut, on a sauté 2 lignes.
les noms des personnes sont saisies au clavier au niveau du
fichier executable c'est a dire au moment où on a ouvert la
console.
bonne chance!
correction:
|
Facebook|
Twitter