Programmation Orientée Système 2 Cours 2: Premiers Pas en C

Programmation Orientée Système
Cours 2: Premiers Pas en C
Francesco Belardinelli
Laboratoire IBISC
Diapos basées sur les notes Programmation en langage C par Mme Anne Canteaut
17 janvier 2017
Cours 2
1. Variables
2. Affectations aux variables
3. les Types Prédéfinis
4. les Constantes
5. les Opérateurs
6. les Fonctions d’Entrée et Sortie
Variables
Identificateurs de variables
• valides : x, x1, x_1, _abc, ABC123z7, sum, RATE, count, data2, Big_Bonus
• pas valides : 12, 3X, %change, data-1, myfirst.c, PROG.CPP
Régle générale :
• commence par une lettre a, . . . , z, A, . . . , Z ou
• peut contenir les caractères a, . . . , z, A, . . . , Z , 0, . . . , 9,
• jusqu’à 31 caractères significatifs
• les compilateurs font la différence entre majuscules et minuscules :
rate 6= RATE 6= Rate
Mots réservés
Mots prédéfinis du langage C ne pouvant être utilisés comme identificateurs :
• Qualificateurs de données : char, const, double, float, int, long, short,
signed, unsigned, void, volatile.
• Classes d’allocation : auto, extern, register, static.
• Constructeurs : enum, struct, typedef, union.
• Instructions : do, for, while, case, default, if, else, switch, break,
continue, goto, return.
• Divers : asm, fortran, sizeof.
Déclaration de Variables : exemple
#include <stdio.h>
int main(){
/* déclaration de variables */
int nombre_de_bonbons;
double poid_individuel, poid_total;
/* instructions */
printf("Saisissez le nombre de bonbons dans le paquet\n");
printf("et le poid des bonbons en grammes:\n");
scanf("%d",&nombre_de_bonbons);
scanf("%lf",&poid_individuel);
poid_total = nombre_de_bonbons * poid_individuel;
printf("Si tu as %d bonbons,\n", nombre_de_bonbons);
printf("chacun de poid %f, alors\n", poid_individuel);
printf("le poid total est %f.\n", poid_total);
return 0;
}
• déclaration de trois variables :
I une variable de type int.
I deux variables de type double.
• variables du même type séparées par des ,
• variables de types différents séparées par des ;
Les Types Prédéfinis
• C est un langage typé
• les variables (et aussi les fonctions, les constantes,. . .) sont typées
• le type d’un objet définit la façon dont il est représenté en mémoire.
• la mémoire de l’ordinateur se décompose en une suite continue d’octets
• chaque octet dans la mémoire est caractèrisé par son adresse (entier)
• quand une variable est définie, il est lui attribuée une adresse
• cette variable correspondra à une zone de la mémoire dont la longueur (le nombre
d’octets) est fixée par le type
type
char
int
float
double
nom
caractères
entiers
réels
réels
# octets
1 octets
4 octets
4 octets
8 octets
plage
dépend du clavier
[−231 ; 231 [
[10−38 ; 1038 [
[10−308 ; 10308 [
Le Type Caractère
• le mot-clef char désigne un objet de type caractère
• un char peut contenir n’importe quel élément du jeu de caractères de la machine
utilisée
• codé sur 1 octet
• peut être assimilé à un entier
#include <stdio.h>
int main(){
char c = ’A’;
printf("%c\n", c + 1);
return 0;
}
Le Type Entier
• le mot-clef int désigne un objet de type entier
• codé sur 4 octet
• le type short int est codé sur 2 octets
• le type long int est codé sur 8 octets
type
short int
int
long int
nom
entiers
entiers
entiers
# octets
2 octets
4 octets
8 octets
plage
[−215 ; 215 [
[−231 ; 231 [
[−263 ; 263 [
• la fonction sizeof(expr), où expr est un type ou un objet, renvoie un entier
égal au nombre d’octets nécessaires pour stocker le type ou l’objet.
short int x;
taille = sizeof(short int);
taille = sizeof(x);
Le Type Réel
• les mots-clef float et double désignent des nombres réels
• codé sur 4 et 8 octet
• le type long double est codé sur 16 octets
type
float
double
nom
réels
réels
# octets
4 octets
8 octets
plage
[10−38 ; 1038 [
[10−308 ; 10308 [
• les réels sont stockés en mémoire sous la représentation de la virgule flottante
normalisée : signe 0, mantisse B exposant , où B = 2.
Les Constantes
• costante : valeur qui apparaı̂t littéralement dans le code source d’un programme
• le type de la constante est déterminé par la façon dont la constante est écrite
• 4 types : entier, flottant (nombre réel), caractère, énumeration
• les constantes sont utilisées, par exemple, pour initialiser une variable
Les Constantes Entières
Peuvent être représentées en 3 bases différentes :
• décimale (ex. 0 ou 1234)
• octale (commence par 0, ex. 00 ou 0377)
• hexadécimale (commence par 0x ou 0X, ex. 0xe ou 0xff)
Par défaut, une constante entière est représentéee avec le format interne le plus court
parmi int, long int et unsigned long
Les Constantes Réelles
• représentées par la notation par mantisse et exposant
• l’exposant est introduit par la lettre e ou E (nombre décimal éventuellement signé)
• par défaut, une constante réelle est représentée avec le format du type double.
• on peut influer sur la représentation interne de la constante en lui ajoutant un des
suffixes f (ou F) et l (ou L)
constante
type
12.34
12.3e-4
12.34F
12.34L
double
double
float
long double
Les Constantes Caractère
• pour désigner un caractère imprimable, il suffit de le mettre entre apostrophes
(ex. ’A’ ou ’$’)
• exceptions : \\, \’, \?, \"
• les caractères non-imprimables les plus fréquents disposent d’une notation simple
\n
\t
\v
\b
\r
\f
\a
nouvelle ligne
tabulation horizontale
tabulation verticale
retour arrière
retour chariot
saut de page
signal d’alerte
Les Constantes Chaı̂nes de Caractères
• suite de caractères entourées par des guillemets
"Ceci est une chaine de caractères"
• une chaı̂ne de caractères peut contenir des caractères non imprimables
"ligne 1 \n ligne 2"
• longues chaı̂nes de caractères sur plusieurs lignes
"ceci est une longue longue longue longue longue longue \
chaine de caractères"
Les Opérateurs : Affectation
• symbolisée par le signe =.
variable = expr
• le terme de gauche de l’affectation peut être une variable simple, un élément de
tableau mais pas une constante.
• l’instruction a pour effet d’ évaluer expr et d’affecter la valeur obtenue à
variable.
• ex : poid_total = nombre_de_bonbons * poid_individuel;
Les Opérateurs Arithmétiques
symbole
+
*
/
%
opération
changement de signe (unaire)
addition
soustraction
multiplication
division
reste de la division (modulo)
• l’opérateur / produit une valeur entière si les deux opérandes sont de type entier
• par contre, / délivrera une valeur réelle si l’un des opérandes est de type réel.
Comparez
float x;
x = 3 / 2;
et
x = 3 / 2.;
• pour calculer x y il faut utiliser la fonction pow(x,y) de la librairie math.h
Les Opérateurs Relationnels
symbole
>
>=
<
<=
==
!=
relation
strictement supérieur
supérieur ou égal
strictement inférieur
inférieur ou égal
égal
différent
• syntaxe : expr_1 op expr_2
• la valeur rendue est de type int
• elle vaut 1 si la condition est vraie, et 0 sinon.
Les Opérateurs Relationnels : exemple
• ne pas confondre l’opérateur de test d’égalité == avec l’opérateur d’affection =.
#include <stdio.h>
int
main(){
int a = 0;
int b = 1;
if (a = b)
printf("a et b sont egaux \n");
else
printf("a et b sont differents \n");
return 0;
}
• résultat : a et b sont egaux !
Les Opérateurs Booléens
symbole
&&
||
!
opération
et logique (conjonction)
ou logique (disjonction)
non logique (négation)
• syntaxe : expr_1 op_1 expr_2 op_2 ... expr_n
• similaires aux opérateurs relationnels :
• la valeur rendue est de type int.
• elle vaut 1 si la condition est vraie, et 0 sinon.
• exemple :
int i;
int p[10];
i = 11;
if ((i >= 0) && (i <= 9) && !(p[i] == 0))
...
• si i n’est pas entre 0 et 9, la dernière clause ne sera pas évaluée
Les Opérateurs Logiques bit à bit
symbole
&
|
^
~
<<
>>
opération
et
ou inclusif
ou exclusif
complément à 1
décalage à gauche
décalage à droite
• considérez les entiers a = 23 et b = 77 de type unsigned char (sur 8 bits).
expression
a
b
a&b
a|b
a^b
~a
b<<2
b<<5
b>>1
binaire
01001101
00010111
00000101
01011111
01011010
10110010
01011100
11100000
00001011
décimale
77
23
5
95
90
-78
92
736
11
Les Opérateurs d’Affectation Composée
+=
-=
*=
/=
%=
• l’instruction
expr_1 op_1= expr_2
est équivalent à
expr_1 = expr_1 op_1 expr_2
&=
^=
|=
<<=
>>=
Les Opérateurs d’Incrémentation et de Décrémentation
• les opérateurs d’incrémentation ++ et de décrémentation -- sont utilisés en
suffixe (i++) et en préfixe (++i).
• mais le résultat est différent :
int a = 3, b, c;
b = ++a;
c = b++;
/* a et b valent 4 */
/* c vaut 4 et b vaut 5 */
L’Opérateur de Conversion de Type (Cast)
• permet de modifier explicitement le type d’un objet
• syntaxe : (type)objet
#include <stdio.h>
int main(){
int i = 3, j = 2;
float k = 2.5;
printf("%f \n",(float)i/j);
printf("%d \n",(int)k);
return 0;
}
L’Opérateur d’Adresse
• l’opérateur d’adresse & retourne l’adresse-mémoire d’une variable.
• syntaxe : &objet
#include <stdio.h>
int main(){
int i;
printf("adresse de la variable i = %ld \n",(long int)&i);
return 0;
}
Les Fonctions d’Entrée-Sortie
• fonctions de la librairie standard stdio.h
• utilisées avec les unités classiques d’entrée et sortie (clavier et écran)
#include <stdio.h>
• sur certains compilateurs, l’appel à la librairie stdio.h n’est pas nécessaire pour
utiliser printf et scanf.
La fonction d’écriture “printf”
printf("chaine de controle",expr_1, ..., expr_n);
• La chaı̂ne de contrôle contient le texte à afficher et les spécifications de format
correspondant à chaque expression de la liste
• Les spécifications de format sont introduites par le caractère % suivi d’un
caractère désignant le format d’impression
• largeur minimale du champ d’impression : (ex. %10d)
• précision : %.12f
La fonction d’ écriture “printf()” : exemple
#include <stdio.h>
int main(){
int i = 23674;
int j = -23674;
long int k = (1l << 32);
double x = 1e-8 + 1000;
char c = ’A’;
char *chaine = "chaine de caracteres";
printf("impression de i: \n");
printf("%d \t %u \t %o \t %x",i,i,i,i);
printf("\nimpression de j: \n");
printf("%d \t %u \t %o \t %x",j,j,j,j);
printf("\nimpression de k: \n");
printf("%d \t %o \t %x",k,k,k);
printf("\n%ld \t %lu \t %lo \t %lx",k,k,k,k);
printf("\nimpression de x: \n");
printf("%f \t %e \t %g",x,x,x);
printf("\n%.2f \t %.2e",x,x);
printf("\n%.20f \t %.20e",x,x);
printf("\nimpression de c: \n");
printf("%c \t %d",c,c);
printf("\nimpression de chaine: \n");
printf("%s \t %.10s",chaine,chaine);
printf("\n");
return 0;
}
La fonction d’ écriture “printf()” : exemple (suite)
[fbelard@fbelard lec2]$ ./ex_printf
impression de i:
23674
23674
56172
5c7a
impression de j:
-23674
4294943622
37777721606
ffffa386
impression de k:
0
0
0
4294967296
4294967296
40000000000
100000000
impression de x:
1000.000000
1.000000e+03
1000
1000.00
1.00e+03
1000.00000001000000793283
1.00000000001000000793e+03
impression de c:
A
65
impression de chaine:
chaine de caracteres
chaine de
La fonction de saisie “scanf()”
scanf("chaine de controle",arg_1, ..., arg_n);
• La fonction scanf permet de saisir des données au clavier et de les stocker aux
adresses spécifiées par les arguments de la fonctions
• les conversions de format sont spécifiées par un caractère précédé du signe %
• exemple :
#include <stdio.h>
main(){
int i;
printf("Saisissez un entier sous forme hexadecimale i = ");
scanf("%x",&i);
printf("i = %d\n",i);
return 0;
}
Impression et Lecture de Caractères
• les fonctions getchar et putchar permettent de lire et d’imprimer des caractères.
#include <stdio.h>
int main(){
char c;
while ((c = getchar()) != EOF)
putchar(c);
return 0;
}
• la fonction getchar retourne un int correspondant au caractère lu.
Les Fonctions “gets()”, “atof()” et “atoi()”
• gets : reçoit en entrée une chaı̂ne de caractère
• atof : conversion de String à double
• atoi : conversion de String à int
Conclusions du Cours 2
1. Variables
2. Affectations aux variables
3. les Types Prédéfinis
4. les Constantes
5. les Opérateurs
6. les Fonctions d’Entrée et Sortie