Variables : déclarations scanf

!
Syntaxe : Type identificateur1, identificateur2, …,…. ;
Exemples entrées résultats
Exemple: char c1, c2, c3;
int i, j, var_ent; char c1, c2, c3;
abc c1=a c2=b c3=c
scanf(‘’%c%c%c‘’,&c1,&c2,&c3);
Variables : initialisations
Les variables doivent être déclarées avant leur utilisation dans un début de bloc (juste après{),
zone des déclarations:

void main(void) void main(void)

{ {
est équivalent à
char c; char c = 'A'; char c;
int i, j, k; int i;
c = 'A'; int i=50,j, k;
float x;
i = 50; j=k=10;
j =10; = opérateur d’affectation
K=10; scanf(‘’%2d %5f %c‘’,&i,&x,&c); 12 123.567 r i=12 x=123.5 c=6

Cette règle s'applique à tous types : char, int, float ... 14 15

Affichages et saisies LES DECLARATIONS DE CONSTANTES

Librairie : stdio.h 1ere méthode: définition d'un symbole à l'aide de la directive de compilation #define.

Fonction Syntaxe Description Le compilateur ne réserve pas

Exemple: #define PI 3.14159 de place en mémoire
printf printf( const char *format [, arg [, Écriture formatée void main()
arg]...]); sortie standard
{
scanf scanf( const char *format [, arg [, Lecture formatée float perimetre,rayon = 8.7;
arg]...]); entrée standard
perimetre = 2*rayon*PI;
putchar putchar(int c); Écrire le caractère c ....
}
getchar getchar(); Lecture d'un caractère
<conio.h>
getch
getch(); Syntaxe : #define identificateur texte(valeur) !
puts *puts(char *s); Ecriture/Lecture d'une Les identificateurs s'écrivent
*gets(char *s); chaîne de caractères, #define TAILLE 100 traditionnellement en
gets terminée par \n #define MAXI (3 * TAILLE + 5) majuscules, mais ce n'est pas
sprintf sprintf(char *s, char *format, arg ...); Ecrit dans la chaîne #define nom_macro(identif_p1 , ... ) texte une obligation.
d'adresse s. #define SOMME(X,Y) X+Y
sscanf sscanf(char *s, char *format, pointer Lit la chaîne d'adresse s. #define MULTIP(A,B) (A)*(B)
...);

16 17

1
 LES DECLARATIONS DE CONSTANTES
Identificateurs
Les identificateurs nomment les objets C (fonctions, variables ... )
2eme méthode: déclaration d'une variable, dont la valeur sera constante pour tout le programme.
− C'est une suite de lettres ou de chiffres.
− Le premier caractère est obligatoirement une lettre.
Exemple: − Le caractère _ (souligné) est considéré comme une lettre.
void main() Le compilateur réserve de la − Reconnaissance les 31 premiers caractères.
{ place en mémoire (ici 4 octets).
const float PI = 3.14159; Le C distingue les minuscules des majuscules.
const int JOURS = 5;
Exemples :
float perimetre,rayon = 8.7;
abc, Abc, ABC sont des identificateurs valides et tous différents.
perimetre = 2*rayon*PI;
.... /*ERREUR !*/ On ne peut Identificateurs valides :
JOURS = 3; changer la valeur d’une const. xx y1 somme_5 _position
.... ! Noms surface fin_de_fichier VECTEUR
} Identificateurs invalides :
3eme commence par un chiffre
x#y caractère non autorisé (#)
no-commande caractère non autorisé (-)
taux change caractère non autorisé (espace)

18 19

Les opérateurs arithmétiques

Un identificateur ne peut pas être un mot réservé du langage :
Le C propose les opérateurs suivants :

auto double int struct + addition

break else long switch - soustraction
case enum register typedef * multiplication
char extern return union / division
const float short unsigned
% modulo (reste de la division entière )
continue for signed void
default goto sizeof volatile % ne peut être utilisé qu'avec des entiers
do if static while

7/2 3

RQ : Les mots réservés du langage C

doivent être écrits en minuscules.
7.0/2
7/2.0
7.0/2.0
} 3.5

20 21

2
 Les opérateurs de comparaison
Utiliser des opérateurs arithmétiques
< plus petit Le type booléen
n'existe pas. Le
Le compilateur considère le type des opérandes <= plus petit ou égal résultat d'une
expression logique
pour savoir comment effectuer les opérations > plus grand vaut 1 si elle est
vraie et 0 sinon.
>= plus grand ou égal
k= 5/4 = 1 void main(void) == égal
{
int i = 5, j = 4, k;
!= différent !
h = 5.0/4.0 = 1.25 double f = 5.0, g = 4.0, h; Réciproquement,
Les opérateurs logiques toute valeur non
k = i / j; nulle est considérée
&& et comme vraie et la
h = f / g; valeur nulle comme
h = i / j; || ou (non exclusif) fausse.
h = 5/4 = 1.0000
} ! non

22 23

int i;
Exemple
float f;
char c;
Contractions d'opérateurs
i = 7; f = 5.5; c = 'w'; Il y a une famille d’opérateurs
f>5 ====> vrai (1) += -= *= /= %=
(i + f) <= 1
c == 'w‘
====>
====>
faux (0)
vrai (1)
&= |= ^=
c != 'w' ====> faux (0)
c >= 10*(i + f) ====> faux (0)
(i >= 6) && (c == 'w') ====> vrai (1) Pour chacun d’entre eux
(i >= 6) || (c == 119) ====> vrai (1)
expression1 op= expression2
!expr1 est vrai si expr1 est faux et faux si expr1 est vrai ;
expr1&&expr2 est vrai si les deux expressions expr1 et expr2 sont vraies et est équivalent à:
faux sinon. L'expression expr2 n'est évaluée que dans le cas où l'expression (expression1) = (expression1) op (expression2)
expr1 est vraie ;
a += 32; f /= 9.2; i *= j + 5;
expr1 || expr2 est vrai si expr1 est vrai ou expr2 est vrai et il est faux sinon.
L'expression expr2 n'est évaluée que dans le cas où l'expression expr1 est a = a + 32; f = f / 9.2; i = i * (j + 5);
fausse.
24 25

3
 Incrément et décrement Préfixe et Postfixe
#include <stdio.h>
C a deux opérateurs spéciaux pour incrémenter (ajouter 1)
et décrémenter (retirer 1) des variables entières int main(void)
{
++ increment : i++ ou ++i est équivalent à i += 1 ou i = i + 1 int i, j = 5;
équivalent à:
1. j++;
-- decrement
i = ++j;
2. i = j; !
Ces opérateurs peuvent être préfixés (avant la variable) ou printf("i=%d, j=%d\n", i, j);
postfixés (après)
j = 5; équivalent à:
int i = 5, j = 4; i = j++; 1. i = j;
“i” vaudra 6 printf("i=%d, j=%d\n", i, j); 2. j++; !
i++;
“j” vaudra 3 return 0;
--j; } i=6, j=6
++i; i=5, j=6
“i” vaudra 7
26 27

Les Conversions (casting) de types

Le langage C permet d'effectuer des opérations de conversion de type.
On utilise pour cela l'opérateur de "cast" ().
#include <stdio.h>
#include <conio.h>
void main() Conversion float -> int: 89.67 -> 89
{
Conversion int -> float: 4660 -> 4660.00
int i=0x1234, j;
char d,e; Conversion int -> char: 1234 -> 34
float r=89.67,s; Conversion float -> char: 89.67 -> 89
j = (int)r;
Pour sortir frapper une touche
s = (float)i;
d = (char)i;
e = (char)r;
printf("Conversion float -> int: %5.2f -> %d\n",r,j);
printf("Conversion int -> float: %d -> %5.2f\n",i,s);
printf("Conversion int -> char: %x -> %x\n",i,d);
printf("Conversion float -> char: %5.2f -> %d\n",r,e);
printf("Pour sortir frapper une touche ");
getch(); // pas getchar
}
28