Cours Techniques de Programmation

Techniques de
Programmation
Pr. : Mohamed El KAMILI
Contact : mohamed.elkamili@usmba.ac.ma
Cycle : Ingénieur
Département : GE
Année : 2018/2019
Techniques de Programmation 1/102

Plan
 Généralités
 Programmation informatique
 Algorithmique
 Programmation en langage C
Introduction
Notion de variable en C
Mots-clés du langage C
Structures de contrôle
Les tableaux
Variables composites
Les fonctions
La récursivité
Les fichiers
Programmation en C
Historique
 L’histoire du C est très liée à l'histoire du système UNIX.
 En 1969, la 1ère version du système UNIX voit le jour

programmée en assembleur.
 Ken Thompson créa un nouveau langage de programmation,
nommé B.
 En 1971, création du successeur de B, nommé C, créé par
Dennis Ritchie.
 En 1983, un standard pour le langage C est créé :
 la norme ANSI (American National Standards Institute).

 La plupart des compilateurs (Borland, Microsoft, GNU CC,
GCC, …) utilisent ce standard.
 un programme écrit en ANSI C est compilable presque
partout.

Programmation en C
Caractéristiques du langage C
 Langage structuré;
 Langage modulaire : Peut être découpé en modules qui

peuvent être compilés séparément;
 Langage universel : Permet de développer tout type

d’applications ; OS, jeux, …;
 Langage typé : Tout objet C doit être préalablement déclaré

avant d’être utilisé;
 Langage puissant et efficace;
 Langage portable : Sur n'importe quel système en possession

d'un compilateur C.

Programmation en C
 Le langage C est un langage compilé;
 Les compilateurs assurent les opérations suivantes:

 Analyse lexicale;
 Pré-traitement (préprocesseur);
 Analyse syntaxique (parsing);
 Analyse sémantique; et
 Génération de code optimisé en langage bas niveau.

Programmation en C
Fichier Compilateur C
Source C
Code
Assembleur
Assembleur
Code Objet
Code Linker
exécutable

Programmation en C
Anatomie d’un programme C
Programme typique en C
include
Main() toujours la
1ère fonction appelée
main()
fonction a() instructions
fonction b() instructions
instructions

Programmation en C
Programme typique en C
/* exemple de programme C :
-somme des nb de 1 à 10 et affichage de la valeur*/
En C le programme principal 1
#include <stdio.h> 0 s'appelle toujours main
int main (void) 1
{ déclarations de variables de
type entier (cases mémoire 2
int somme; int i; 2 pouvant contenir un entier)
somme = 0; 3
instruction d'affectation de
valeur à la variable somme 3
for (i = 1; i <= 10; i++)
4 { l'instruction entre accolades
somme = somme + i; est exécutée pour les valeurs 4
de i allant de 1 à 10
}
printf ("%d\n", somme); 5 affiche à l'écran la valeur de 5
somme = 0; l'entier contenu dans somme
}

Programmation en C
Instruction en langage C
 Les actions ou "instructions" en langage C ne sont en fait que
des opérations élémentaires (+,-, * etc…) sur des données
unitaires (variables).
 Chaque instruction est suivie d'un ;
 Le début d'un bloc est signalé par un { , la fin d'un bloc par }.
Un bloc devient l'équivalent syntaxique d'une instruction.
Exemple: {
x=1 Obligatoire
x=1;
y=2
Calcul
y=2;
z = x+y z=x+y;
imprimer z printf("%d",z);
};
optionnel
Programmation en C
Type d’instructions en langage C
 Déclarations des variables
 Affectations
 Opérations
 Fonctions
 Contrôle

Programmation en C
La notion de variable en C
Nom d’une variable
La norme ANSI C est assez souple pour ce qui concerne le

nommage des variables, mais aussi assez stricte sur certains
points : Un nom de variable :
Peut contenir des lettres de A à Z, et de a à z, ainsi que les

dix chiffres de 0 à 9, et le caractère underscore ('_');
Ne doit pas commencer par un chiffre;
Le langage C est sensible à la casse.

Programmation en C
Type d’une variable
Toutes les variables doivent être explicitement typées (pas

de déclaration implicite comme en fortran)
Il y a globalement trois (quatre ?) types de variables :

int,
Les entiers : short int, long int
Les réels : float, double, long double
Les caractères : char
Rien … : void
Exemples : short int ma_note;
double cheese;
char avoile;

Programmation en C
Déclaration d’une variable
Déclarer une variable est une opération extrêmement

simple, qui nécessite deux choses :
 Le type de de variable que l'on souhaite créer,
 et le nom que l'on souhaite lui donner.
Le type de variable que l'on souhaite créer dépend, bien

évidemment, de nos besoins, et nous le choisirons parmi les
types disponible ou encore crées.
Exemple : int a;
float note;

Programmation en C
Initialisation d’une variable
On appelle "initialisation" d'une variable le fait de lui

donner une valeur pour la première fois;
Pour donner une valeur à une variable (on dit "affecter"
une valeur à une variable), on utilise l'opérateur
d'affectation, '=' (Le symbole égal);
Cet opérateur affecte à la variable placée à sa gauche le
résultat de l'expression placée à sa droite.
En C, on peut initialiser une variable à sa déclaration !

Exemples :
short int age=21;
int x=-3, b=15;

Programmation en C
Portée ou visibilité d’une variable
Variable globale : Une variable déclarée au début du code, c'est-à-dire

avant tout bloc de donnée, sera globale, on pourra alors l'utiliser à partir
de n'importe quel bloc d'instruction.
Variable locale : Une variable déclarée à l'intérieur d'un bloc

d'instructions (dans une fonction ou une boucle par exemple) aura une
portée limitée à ce seul bloc d'instruction, c'est-à-dire qu'elle est
inutilisable ailleurs. On parle alors de variable locale.

Programmation en C
Le type Caractère
Caractère : Symboles alphanumériques (a,z,0,1,9) + caractères

spéciaux (retour à la ligne, beep, etc..)
Un caractère est représenté sur un octet (8 bits) suivant la
table ASCII (American Standard Code for Information
Interchange)
Exemple : 'a' = 9710 = 6116 = 0110 00012 =141
Table ASCII
ex : code ASCII du 'A' = 65
'A'<'B'<……..< 'Z'
'0'<'1'<'2'<…..<'9'
'a'<'b'<……….<'z'
Programmation en C
Le type Caractère : Table ASCII

Programmation en C
Le type Caractère : Table ASCII
A retenir :
les chiffres sont codés suivant un ordre croissant (48 à 57)
idem pour les lettres (65 à 90, 97 à 122)
code des majuscules est inférieur au code des minuscules

(différence constante = 32)
les codes supérieurs à 128 dépendent de la langue :
é, ö , ä, æ, œ etc…

Programmation en C
Le type Entier
C’est une variable codée sur 2 ou 4 octets suivant le calculateur

n 1
x   xi 2i , xi  0,1, n  16 ou 32
i 0
 Sur deux octets on peut coder les nombres de 0 à 216-1 (0 à 65535)
Représentation en base 2: les bits sont rangés dans des cellules

correspondant à leur poids, on complète à gauche par des 0
Exemple : 13 = 8 + 4 +1 = 1*23+1*22+0*21+1*20
=0000000000001101
Déclaration d'une variable entier naturel x
unsigned int x;
short unsigned int x; (on force sur 16 bits)
long unsigned int x; (on force sur 32 bits)
Programmation en C
Le type Entier relatif
La première idée est de marquer le signe du nombre de façon simple : le

signe puis la représentation de sa valeur absolue. Ainsi :
00000110 = +6 en décimal
Et
10000110 = −6 en décimal
Malheureusement cette représentation possède deux inconvénients:

Le premier (mineur) est que le nombre zéro (0) possède deux
représentations: 00000000 et 10000000, respectivement égales à 0 et −0.
L'autre inconvénient (majeur) est que cette représentation impose de
modifier l'algorithme d'addition ; si un des nombres est négatif, l'addition
binaire usuelle donne un résultat incorrect.
Exemple : 00000011 + 10000100 = 10000111
Soit 3 + (−4) = (−7) au lieu de (−1)
Programmation en C
Le type Entier relatif : Complément à 2
Implantation sur 2 ou 4 octets suivant le compilateur

Représentation sur n bits : codage complément à 2
n2
x   xn 1 2 n 1   xi 2i , xi  0,1
i 0
Déclarations
int a,b;
….
a = 1;
….
b= -3;
Programmation en C
Si xn-1 = 0 : nombre positif,

xn-1 = 1 : nombre négatif
Exemple sur 16 bits

+5 = 1 * 22 + 0 * 21 + 1 * 20 = 0000 0000 0000 0101
-3 = -215+ 214 + 213 + 212 + 211 + 210 + 29 + 28 + 27 + 26 + 25 + 24

+ 23 + 1.22 + 0. 21 + 1.20
= 1111 1111 1111 1101
-3 = -27 + 26 + 25 + 24 + 23 + 1.22 + 0. 21 + 1.20

Programmation en C
Représentation non symétrique : le plus petit nombre n’a

pas d’opposé : sur n bits
le plus grand entier positif est 2n-1-1
le plus petit entier négatif est -2n-1
000
111 001
0
-1 1
Exemple sur 3 bits :
110 -2 2 010
-3 3
101 -4 011
100
Programmation en C
Le type réel
Déclaration
float x,y;
x = 3.14;
y = 2.0 e+3;
Implantation sur 4 octets

Représentation suivant le compilateur
En général mantisse exposant (norme IEEE)
L’ensemble de valeurs : 10-38 < x < 1038
Extension :
double x; x est codé sur 8 octets

Programmation en C
Le type réel : Représentation (virgule flottante selon la norme IEEE)
M : Mantisse ; calage = 2 -1 , k nombre de bits attribué à

l’exposant
Représentation IEEE 754 (signe 1 bit, mantisse et exposant : le
tout sur 32 ou 64 bits pour simple et double précision)
SM : signe de la mantisse : 1 bit
Eb : exposant biaisé (décalage) : 8 ou 11 bits (E=Eb+calage)
M : Mantisse : 23 ou 52 bits SM E M

Programmation en C
Le type réel : Représentation
Signe : bit de poids fort (0 = + ; 1 = -)

Exposant
placé avant la mantisse pour simplifier les comparaisons (pour
ceci il ne doit pas être représenté en complément à deux : -1 > 2)
sur 8 bits : 0…256
sans signe mais décalé de 127 (simple précision) :
Eb = 1 ⇒ E = 1 + 127 = 128
Eb = -3 ⇒ E = -3 + 127 = 124
les exposants 255 (erreur) et 0 (nb dénormalisé) sont interdits
Mantisse
Normalisée : bit de poids fort n’est pas 0 et un seul chiffre avant
la virgule
Exemple : 11,012 = 1,101 * 21

Programmation en C
Résumé sur les types
Caractère : 1 octet
Ex : 'a' = 6116 0 1 1 0 0 0 0 1
Entier relatif : 2 ou 4 octet, représentation complément à 2

Ex 1 : +5 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1
Ex 2 : -5 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1
x : indique le signe
Réel : 4 octets, représentation virgule flottante
Ex : -6,5 = -110,12 = -1,101 * 22 2+127 = 129 = 27 +20
1 1 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 … 0 0 0

Programmation en C
Complément de type : static
Static : une telle variable maintient sa valeur à travers les appels de

la fonction
void inc( ) void inc( )

{ {
int i=0; static int i=0;
i++; //i=i+1; i++;
printf ("%d", i); printf ("%d", i);
} }
1, 1, 1, 1, … 1, 2, 3, 4, …
/* i est initialisée à chaque appel de /* i est initialisée à 0 à la
la fonction inc() */ compilation seulement */
Programmation en C
Complément de type : register
Register
Une déclaration "registre" indique au compilateur qu'une variable

sera utilisée fréquemment.
Si c'est possible, le compilateur utilisera un registre pour implanter

la variable plutôt qu'un emplacement mémoire (vitesse d'exécution)
register int i;

Programmation en C
Conversion de type : Le casting
Conversion explicite : ( type ) expression

Exemple :
int a; float x; char c;
a=2;
x=a;
x=2.3;
a= (int) (x+1);
a = 98;
c = (char) a; => c='b'
Conversion implicite : Conversion du type le plus faible vers le type le plus
fort : char < short ≤ int ≤ long < float < double
Exemple :
int a; float x; char c;
a=2; x= a;
x=2.3;
a= x+1;
a = 98;
c = a; => c='b'

Programmation en C
Conversion de type : Le casting
Exemples :
char c; int i; float f;
// conversion entier vers char
c=98; // implicite : c prend le code ASCII 98 c-à-d 'b'
c = (char) 98; // explicite plus propre
// char vers entier
i= 'a' ; // i prend la valeur 97
i= (int) 'a' ; //plus propre
// entier vers réel
f=3; // f prend la valeur 3.0;
f=(float) 3; //+ propre
//réel vers entier, attention : troncature
i = 3.4; // i prend la valeur 3
i= -3.3; // i prend la valeur -3
i = (int) 3.4; // + propre

Programmation en C
Conversion de type : Modifier la casse
Passer au caractère suivant

char c;
c ='a';
c = c+1; // calcul fait en entier puis résultat converti en char
c = (char) ((int) c+1) ; //+ propre
Conversions majuscule  minuscule

char c;
c='t';
// conversion en Majuscule
c=c-32; // c contient 'T'
ou mieux
c=c-('a'-'A');
c=c+1; // c contient 'U'
// conversion en minuscule
c=c+32;
ou c=c+('a'-'A')
// conversion en Majuscule
if ((c >= 'a') && (c <= 'z')) c = c-('a'-'A');
Programmation en C
Les constantes
Une constante est une variable dont la valeur ne peut pas changer
durant la durée de vie d’un programme
Directive du préprocesseur
Utilisation du mot clé define qui est placé au début du programme
Instruction de déclaration
Utilisation du mot clé const qui est placé avant ou après le type de la
variable

Programmation en C
Les constantes : exemples
#include <stdio.h>
#define CO 10
int c = 5;
void main(){
int a, b;
scanf("%d", &a);
scanf("%d", &b);
printf("La résultat est : %d", (a+b)*c/CO);
}
#include <stdio.h>
int const co = 5;
void main(){
int a, b;
scanf("%d", &a);
scanf("%d", &b);
printf("La résultat est : %d", (a+b)*co);
}
Programmation en C
Expression en C
Une expression représente une donnée élémentaire : constante, variable,
un élément de tableau, la référence à une fonction ou à une valeur, le
résultat d'un calcul etc ….
Exemples
3
a+b
x=y
c = a+b
x <= y
x == y
i++
sin(3.14)
Toute expression a une valeur !

Programmation en C
Opérateurs arithmétiques
Opérateurs binaires
+,-
* , / , % (modulo)
Les opérandes doivent être des valeurs numériques.
entier opérateur entier => résultat entier
réel opérateur réel => résultat réel
entier opérateur réel => résultat réel
Exemples
int a,b; float a,b;
a=10; b= 3 a=12.6; b= 3.0
a+b 13 a+b 13.6
a-b 7 a-b 9.6
a*b 30 a*b 37.8
a/b 3 (division euclidienne) a/b 4.2 (division réelle)
a%b 1 a%b erreur de syntaxe

Programmation en C
Opérateurs binaires
Opérateur % :
- int a;
- float x;
(a+x) % 4 incorrect.
((int) (a+x))%4 correct
- si l'un des opérandes est négatif, le résultat est négatif.
Si l'un des opérandes est de type caractère, c'est la valeur du code ASCII
qui est prise (conversion implicite char vers int ou float)

Programmation en C
Opérateurs unaires
1. a/ signe : + , -
Exemple : a = -a;
2. incrémentation, décrémentation : ++ (+1) , -- (-1)

Exemple :
int i =1;
++i;
printf("%d",i) ; -> 2;
Syntaxes : ++i ou i++
++i : la valeur de i est d'abord incrémentée, la valeur résultat est
utilisée dans l'expression courante
i++ : la valeur courante de i est utilisée dans l'expression courante,
puis i est incrémenté

Programmation en C
Opérateurs unaires : i++ ou ++i ?
Exemples
i=1; i=1;
printf("i= %d\n",i); => i=1 printf("i= %d\n",i); => i=1
printf("i= %d\n",++i); => i=2 printf("i= %d\n",i++); => i=1
printf("i= %d\n",i); => i=2 printf("i= %d\n",i); => i=2
Conclusions
1. appendre la règle (pour comprendre des programmes)
2. à n'utiliser que lorsque il n'y a pas d'ambiguïté :
x=y+z++; // à éviter
x++; // pas de risque

Programmation en C
Affectation en C
Affectation simple
syntaxe : variable = expression
la valeur de l'expression est stockée dans la mémoire à l'endroit
réservé pour la variable
Exemples :
a = 2; b=1; c=0;
a = b+c;
a = b && c;
la valeur de l'expression vaut la valeur affectée
Attention : affectation et test d'égalité

if (a=1) instruction1; else instruction2;
L'instruction1 est toujours déclenchée.
a = b = 3; (évaluation de droite à gauche)

Programmation en C
Affectation en C
Affectation complexe
Affectation et opération : +=, -=, *=, /=, %=,<<= , >>=, &=, |=, ^=
Syntaxe : variable opérateur expression

équivalent à : variable = variable opérateur expression
Exemple
int i;
i= 3;
i+=2; (i=i+2;)
printf("%d\n",i);  5

Programmation en C
Fonctions d’entrée/sortie : Sortie standard
Deux fonction de base : putchar() et printf()
Fonction putchar()
Syntaxe : putchar (char)
Exemple
char c;
c='a';
putchar ( c );
putchar ('\n'); équivalent à printf("%c\n%c",c, 'b');
putchar('b');
Affichage sur écran

a
b

Programmation en C
Fonction printf()
Syntaxe : printf (" liste des formats ", arg1, arg2, arg3, …, argn)
les arguments sont des valeurs d'expression à imprimer

le format donne le texte mort et le mode de décodage des arguments
le format est une chaîne de caractères !
Exemple
printf("bon"); printf("jour");printf("\n"); bonjour
i=j=1;
printf("i=%d\n",i); i=1
printf("%d%d%d\n",i,j,i+j); 112
printf("%d\t%d\t%d\t%d\n",i,j,i+j,sqrt(i)); 1 1 2 1
x=3.0;
printf("%f\t%d\n",x,i); 3.000000 1
printf("%d\n%d\n",i,i+j); 1
2

Programmation en C
Fonction printf()
La valeur de retour du printf() est le nombre de caractères écrits et une

valeur négative si il y a eu un problème.
Exemple
int a,x;
a=42;
x = printf ("%d\n",a);
printf ("%d\n",x); => 3

Programmation en C
Fonction printf()
Caractères spéciaux de format

%d : imprime les entiers sur le nombre de caractères nécessaires
%f : imprime les réels avec 6 chiffres de partie décimale
%e : imprime les réels en notation exponentielle
%c : imprime un caractère
%s : imprime une chaîne de caractères jusqu'à rencontrer le caractère
de fin de chaine 0 (erreur si absent)
…..
Caractères d’échapement
\n : saut à la ligne %% affichage du caractère '%'
\t : tabulation \a : alerte ; beep système
\p : saut à la page \\ : affichage du caractère '\'
\0 caractère null ; valeur 0, délimiteur de fin de chaîne de caractères
…. 45/102
Techniques de Programmation
Programmation en C
Fonction printf()
Forçage du nombre de caractères
entiers :
%5d l'entier est imprimé sur 5 caractères au moins (blancs)
avec cadrage à droite
%-5d l'entier est imprimé sur 5 caractères au moins (blancs)
avec cadrage à gauche
réels :
%10f le réel est imprimé sur 10 caractères (en tout) avec 6
chiffres en partie décimale (cadrage à droite)
%-10f idem + cadrage à gauche
limitation de la partie décimale

%20.3f le réel est imprimé sur 20 caractères (en tout) avec 3
chiffres en partie décimale

Programmation en C
Fonction printf()
Format variable
printf("%*d", n, i) : n donne le nombre de caractères pour i
printf("%*.3f", n, x) : n donne le nombre total de caractères pour x
printf("%*.*f", n, m, x) : n donne le nombre de total caractères m donne le

nombre de caractères pour la partie décimale

Programmation en C
Fonctions d’entrée/sortie : Entrée standard
Lecture depuis le clavier
2 fonctions de base : getchar () et scanf()
Elles peuvent être appelées soit indépendamment soit au sein

d'expressions
Exemples
getchar();
while (c==getchar()) {
…..
};

Programmation en C
Fonction getchar()
Sert à la lecture de caractères isolés
 la valeur de getchar() est le code ascii du caractère lu
 utilisation
char c;
c = getchar();
Exemple : on veut lire et mémoriser 2 caractères donnés sur 2 lignes

différentes
char c1,c2;
c1 = getchar(); // acquiert le 1er caractère
getchar (); // filtre le <cr>, on ne mémorise pas la valeur lue
c2 = getchar () // acquiert le 2ème caractère

Programmation en C
Fonction scanf()
Sert à la lecture de données et convertit la succession de caractères donnés
en entiers, flottants, caractères, chaîne de caractères
Syntaxe : scanf (format, arg1, arg2, …, argn)
le nombre d'arguments est quelconque
arg1, arg2,……, argn sont les adresses des variables dans lesquelles on
stocke les valeurs lues
variable simple (entier, caractère, flottant) : &v
le format est une chaîne de caractères précisant le type des arguments afin
de convertir la suite de caractères lus dans les arguments

Programmation en C
Fonction scanf()
Format
chaîne de caractères composée de caractères % suivis d'une lettre et

éventuellement séparés par des blancs
la lettre indique le type de conversion à effectuer
Exemple
int i; float x;
scanf("%d %f", &i, &x);
le %d indique que le premier argument est un entier

le %f indique que le second est un réel
réponse : 23 12.6
23 est converti en entier et stocké dans i
12.6 est converti en flottant et stocké dans x
Programmation en C
Opérateurs relationnels et logiques
Valeur logique :
0 : faux
!0 : vrai
Exemple : if (3) traitement1 ; else traitement 2;
Equivalent à : traitement1;
Relationnels : >= , > , == , <, <= , !=

La valeur de l'expression est 1 si l'expression est vraie , 0 si elle est fausse
Exemple : 2 < 3 vaut 1 , 2 > 3 vaut 0
Attention à la confusion : test d'égalité == et l'affectation =
ex : if (x=0) traitement 1; // au lieu de x==0
else traitement 2;
Conséquence: non seulement le traitement 1 ne sera jamais exécuté
mais en plus x vaudra 0 quelle que soit sa valeur initiale

Programmation en C
Opérateurs relationnels et logiques
Opérateurs logiques :
&& : "et" logique
|| : "ou" logique
! : "non" logique
Dans l'évaluation de l'expression, 0 est considéré comme la valeur

logique "faux", toute autre valeur est considérée comme la valeur
logique "vraie »
La valeur de l'expression est 1 ou 0
Exemples: 2 && 0 vaut 0 et donc est faux
2 || 0 vaut 1 et donc est vrai
!0 vaut 1
!4 vaut 0

Programmation en C
Opérateurs bit à bit
Opèrent sur les représentations binaires des valeurs
& et binaire ,
| ou binaire,
^ ou-exclusif binaire,
~ complément à 1 ,
<<k décalage à gauche de k bits,
>>k décalage à droite de k bits,
Attention : & ≠ &&
Exemples
5 0000 0000 0000 0101
20 0000 0000 0001 0100
5 & 20 0000 0000 0000 0100  5 & 20 => 4
5 | 20 0000 0000 0001 0101  5 | 20 => 21
5 ^ 20 0000 0000 0001 0001  5 ^ 20 => 17
~5 1111 1111 1111 1010  -6
Affectation (bit-à-bit) : &=, |=, ^=, ~=
Programmation en C
L’opérateur conditionnel ternaire ?... : …
Syntaxe
expression1 ? expression2 : expression3
à peu près équivalent à :

if (expression1) expression2; else expression3;
Exemple
maximum = (x>y) ? x : y;
if (x>y) maximum =x ; else maximum = y;
Conseil : ne pas utiliser (peu clair)

Programmation en C
L’opérateur d’adressage
Adresse de : &
Syntaxe : &variable //donne l'adresse mémoire de la variable

Exemple
int i, *adr;
adr = &i;
ne pas confondre avec le "et" bit à bit
Dont l'adresse est : *
Syntaxe : *expression // donne le mot mémoire dont l'adresse est

donnée par l'expression
Exemple
int i, *adr;
i=1;
adr = &i;
printf("%d", *adr);  1

Programmation en C
L’opérateur de taille
L’opérateur : sizeof
Donne la taille de l'implantation ou de l’expression
2 syntaxes possibles
1. sizeof expression
Exemple
int i,j ;
j= sizeof i;  2 ou 4 (octets)
2. sizeof (type)
Exemples
typedef char tab[100];
tab t;
int n;
n = sizeof(int), -> 2 ou 4 (octets)
n = sizeof(tab) -> 100 (char)

Programmation en C
Opérateurs divers
( ) force l'ordre des calculs

ex : 1 + 2 * 3 -> 7
(1+2) * 3 -> 9
[ ] pour les tableaux

t[2] équivalent à *(t+2)
-> et . (opérateurs sur structures, à étudier + tard)

Programmation en C
Priorité des opérateurs
Priorité Opérateurs Description Associativité
15 () [ ] -> . opérateurs d'adressage Gauche
++ -- incrément/décrément
~ complément à un (bit à bit)
! non unaire
14 Droite
&* adresse et valeur (pointeurs)
(type) conversion de type (cast)
+- plus/moins unaire (signe)
13 */% opérations arithmétiques Gauche
12 +- "" Gauche
11 << >> décalage bit à bit Gauche
10 < <= > >= opérateur relationnels Gauche
9 == != "" Gauche
8 & et bit à bit Gauche
7 ^ ou exclusif bit à bit Gauche
6 | ou bit à bit Gauche
5 && et logique Gauche
4 || ou logique Gauche
3 ?: conditionnel Droite
= += -= *= /= %=
2 assignations Droite
>>= <<= &= ^= |=
1 , séparateur Gauche

Programmation en C
Priorité des opérateurs (exercices)
main(){
int x, y , z;
x = 2; x =0 ; y =0; z=0;
x += 3 + 2; printf("%d\n",x); x+=y+=z;
x -= y = z = 4; printf("%d%d%d\n",x,y,z); printf("%d\n", x < y ? y : x) ;
x = y == z; printf("%d%d%d\n",x,y,z); printf("%d\n", x < y ? x++ : y++) ;
x == (y = z); printf("%d%d%d\n",x,y,z); printf("%d, %d\n", x , y);
printf("%d\n", z += x < y ? x++ : y++)
x = 3; y =2 ; z = 1; ;
x = x && y || z ; printf("%d\n", x); printf("%d, %d\n", y , z);
printf ("%d\n", x || ! y && z);
x = y = 0; x = 3; y = z = 4;
z = x ++ -1; printf ("%d, %d\n", x, z); printf("%d\n",( z >= y >= x) ? 1 : 0)
z += -x ++ + ++ y; printf ("%d, %d\n", x, z); ;
printf("%d\n", z >= y && y >= x ) ;
x =1 ; y =1; x = y = z = 0;
printf("%d\n", ! x | x); }
printf("%d\n", ~ x | x);
printf("%d\n", x ^ x);
x <<= 3 ; printf("%d\n", x);
y <<= 3 ; printf("%d\n", y);
y >>= 3 ; printf("%d\n", y);

Cours Techniques de Programmation

Transféré par

Droits d'auteur :

Formats disponibles

Cours Techniques de Programmation

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Techniques de Programmation

Transféré par

Droits d'auteur :

Formats disponibles

Techniques de

Techniques de Programmation 1/102

 En 1969, la 1ère version du système UNIX voit le jour

 En 1983, un standard pour le langage C est créé :

 la norme ANSI (American National Standards Institute).

Techniques de Programmation 3/102

 Langage modulaire : Peut être découpé en modules qui

 Langage universel : Permet de développer tout type

 Langage typé : Tout objet C doit être préalablement déclaré

 Langage puissant et efficace;

 Langage portable : Sur n'importe quel système en possession

Techniques de Programmation 4/102

 Le langage C est un langage compilé;

 Les compilateurs assurent les opérations suivantes:

Techniques de Programmation 5/102

Techniques de Programmation 6/102

fonction a() instructions

fonction b() instructions

Techniques de Programmation 7/102

Techniques de Programmation 8/102

 Déclarations des variables

Techniques de Programmation 10/102

La norme ANSI C est assez souple pour ce qui concerne le

Peut contenir des lettres de A à Z, et de a à z, ainsi que les

Le langage C est sensible à la casse.

Techniques de Programmation 11/102

Toutes les variables doivent être explicitement typées (pas

Il y a globalement trois (quatre ?) types de variables :

Techniques de Programmation 12/102

Déclarer une variable est une opération extrêmement

 Le type de de variable que l'on souhaite créer,

 et le nom que l'on souhaite lui donner.

Le type de variable que l'on souhaite créer dépend, bien

Techniques de Programmation 13/102

On appelle "initialisation" d'une variable le fait de lui

En C, on peut initialiser une variable à sa déclaration !

Techniques de Programmation 14/102

Variable globale : Une variable déclarée au début du code, c'est-à-dire

Variable locale : Une variable déclarée à l'intérieur d'un bloc

Techniques de Programmation 15/102

Caractère : Symboles alphanumériques (a,z,0,1,9) + caractères

Techniques de Programmation 17/102

les chiffres sont codés suivant un ordre croissant (48 à 57)

idem pour les lettres (65 à 90, 97 à 122)

code des majuscules est inférieur au code des minuscules

les codes supérieurs à 128 dépendent de la langue :

Techniques de Programmation 18/102

C’est une variable codée sur 2 ou 4 octets suivant le calculateur

Représentation en base 2: les bits sont rangés dans des cellules

La première idée est de marquer le signe du nombre de façon simple : le

Malheureusement cette représentation possède deux inconvénients:

Implantation sur 2 ou 4 octets suivant le compilateur

Si xn-1 = 0 : nombre positif,

Exemple sur 16 bits

-3 = -215+ 214 + 213 + 212 + 211 + 210 + 29 + 28 + 27 + 26 + 25 + 24

Techniques de Programmation 22/102

Représentation non symétrique : le plus petit nombre n’a

Implantation sur 4 octets

Techniques de Programmation 24/102

M : Mantisse ; calage = 2 -1 , k nombre de bits attribué à

printf("%.f", n, m, x) : n donne le nombre de total caractères m donne le