ALGORITHMIQUE ET PROGRAMMATION C David TADDEI

Plan du Cours Introduction Notions d’algorithmique (algèbre de Boole…) Eléments de base du langage C (types, variables…) Tests, itérations… Fonctions Récursivité Algorithmes : complexité, tris... Gestion dynamique de la mémoire Listes, piles, arbres... Fichiers

Introduction Fiabilité : Validité et Robustesse Efficacité Maintenance, Evolutivité Modularité Réutisabilité (partielle ou totale) Compatibilité Portabilité Ergonomie Intégrité

Introduction Cahier des charges Modélisation Algorithmes Implémentation

Notions d’algorithmique Ensemble des activités logiques qui relèvent des algorithmes (science des algorithmes) un algorithme est un énoncé dans un langage bien défini d’une suite d’opérations permettant de résoudre par calcul un problème types d’algorithmes : séquentiel parallèle distribué

Notions d’algorithmique Variable Un identifiant Un type (entier, réel, booléen, caractère, chaîne de caractères, tableaux) avec des opérations associées Une valeur (information)

Notions d’algorithmique Instruction traitement(s) portant sur les variables Affectation, condition, boucles Fonction Algorithme autonome réalisant une tâche précise Accepte des paramètres, retourne une valeur Contient une Entête (prototype)

fonction somme (n:entier,tab:tableau entier[0..n-1]) : entier début s<-0 pour i de 0 à (n-1) faire s <- s+tab[i] fpour retourne s fin Lexique : - n : entier, nombre d'entiers - tab : tableau entier[0..n-1] - s : entier, somme temporaire Algorithme nb <- lire () si (nb>0) alors remplir (nb,t) ; écrire (somme(nb,t) ; fsi - t : tableau entier[0..n-1] - nb : entier, nombre d'entiers

Notions d’algorithmique Définition du problème Décomposition en sous problèmes Recensement des variables Ecriture de l’algorithme Test de l’algorithme Ecriture du programme Test du programme

Algèbre de Boole Georges Boole (1815 – 1864), mathématicien anglais Algèbre traduisant des signaux en expressions mathématiques Algèbre de la pensée s’appuyant sur une logique binaire Un signal : variables logiques Un traitement : fonctions logiques

Fonctions logiques de base Variable logique : entrée binaire Fonction logique : plusieurs variables logiques en entrée et sortie Porte : fonction logique de base OU : OR : + (expression algébrique) ET : AND : . OU EXCLUSIF : XOR : NON : NO : /A,

Table De Vérité

Algèbre de Boole Egalité : 0 = 0 ; 1 = 1 Négation : /0 = 1 ; /1 = 0 Multiplication : A.B

Lois de composition (règles logiques) Associativité : (A.B).C  A.(B.C) (A+B)+C  A+(B+C) Absorption : A.(A+B)  A A+(A.B)  A Commutativité : A.B  B.A A+B  B+A Distributivité : A+(B.C)  (A+B).(A+C) A.(B+C)  (A.B)+(A.C) Idempotence : A.A  A A+A  A

Lois de composition (règles logiques) Identité : 1.A  A 0+A  A Inversion : A./A  0 A+/A  1 Nullité : 0.A  0 1+A  1 Théorème de Morgan : /(A.B)  /A+/B /(A+B)  /A./B

Exemple de circuit Additionneur : A + B En arithmétique binaire : S = A B ; R = A.B

Exemple de circuit

Petit panorama des langages Source : http://developpeur.journaldunet.com

Critères pour le choix d’un langage Clarté Spécificité Ouverture Ancienneté Popularité

http://www.tiobe.com/tpci.htm

Genèse du C Kenneth Thompson et Dennis Ritchie 1972 : mis au point dans les laboratoires BELL en même temps qu’UNIX ; basé sur Algo -> BCPL -> B 1989 norme ANSI C (ou C89) puis C99… la dernière date de 2003 Kenneth Thompson et Dennis Ritchie

Avantages Simplicité Possibilités Performances (compilé ; très proche du processeur) Très utilisé (notamment dans le monde Unix) Portabilité Légèreté (noyau très simple)

Inconvénients il est très facile d’écrire du code illisible Bonne maîtrise des pointeurs requise pas de « garde-fous » Mise au point plus délicate pour les programmes faisant intervenir des données complexes (bibliothèques) => C++

C’est du C ! main(void) { int x=3,n,m=2,*t,*a,*b=0; while(b?o:((*(t=b=(int*)malloc(o))=2),a=t+1,o))n=*b,n>=m?c:x%n?(int)b++:N); }

Compilateurs C GCC : Gnu Compiler Collection Dev C++ Borland C++ Builder (Kylix) Visual Studio, .Net Et aussi : compilateurs de Watcom, Symantec

Eléments de base du langage C Structure générale d’un programme Considérations lexicales : Mots-clés, Identificateurs Commentaires Variables Types de base Constantes Chaînes de caractères Constantes nommées : #define, Enumérations Opérateurs usuels Instructions Fonctions Objets structurés : Tableaux, Structures Directives du Préprocesseur Bibliothèque standard

Programme minimal #include <stdio.h> int main(void) { /* affichage d’un texte */ printf ("Hello World\n"); return 0; }

Génération du programme Préprocesseur Compilation Assemblage Edition de liens Editeur de liens Code C Compilateur Code machine

Autre exemple de programme #include <stdio.h> #define TVA 0.196f void main () { float fPrixHT , fPrixTTC ; puts ("Veuillez entrer le prix H.T. :"); scanf ("%f",&fPrixHT); fPrixTTC = fPrixHT*(1+TVA) ; printf ("Voici le prix T.T.C. : %f €\n",fPrixTTC); }

Généralités Structure d’un programme : Directives de compilation, déclarations globales (variables, types, fonctions), fonctions Une fonction : entête, bloc Un bloc : déclarations locales, instructions

Considérations lexicales Commentaires Identificateurs Séparateurs Mots-clés

Types de base du C Entier : int, long, short Réel : float, double Caractère : char

Types de base du C char 8 bits Caractère short 16 bits Nombre entier signé int 16, 32 bits Nombre entier signé long 32 ou 64 bits Nombre entier signé float 32 bits Nombre flottant double 64 ou 80 bits ou plus Nombre flottant sizeof : taille d'un type ou variable Rappel : 2^8 = 256

Typedef typedef type-declaration synonym ; Exemple : définition du type byte

Définition de variables

Définition de variables <type> <identificateur>[,<identificateur>,...]; Les tableaux statiques int tiTab2D[4][3]; int iTableau[] = {2,-1,3}; comment stocker une image 320x200 en 256 couleurs ? Les chaînes de caractères char chaine[taille]; char chaine[] = ‘texte‘ ; char chaine[] = {‘t',‘e',’x’...} le dernier caractère est '\0' premier indice : 0

Variables Visibilité des variables Variables statiques static int count = 0 ; Variables constantes et volatiles (ne figurent pas dans le C d’origine) Variables externes

Variables : portée Classe mémoire Zone de validité Durée de vie LOCAL Auto Register Static Bloc Programme GLOBAL Extern Fichier source avec définition et après chaque déclaration tous les modules du programme Fichier source avec définition Programme

Variables int i = 3; /* i est accessible de tous les fichiers */ const int j = 5; /* Synonyme de static const int j = 5; */ extern const int k; /* déclaration de la variable k... */ const int k = 7 ; /* définition. */

Opérateurs Arithmétiques : +, -, *… Relation : ==, <, >=… Logique : !, &&, ||… Affection : = Condition : <exp1>?<exp2>:<exp3>

Opérateurs simples Lvalue : adresse, type, valeur ne sont pas des Lvalue : constantes, tableaux, fonctions Rvalue : type, valeur

Opérateurs simples () : appel de fonction [] : indexation . : sélection dans une structure -> : sélection dans un objet pointé ! : négation ~ : négation bit à bit - : moins unaire * : indirection (accès à un objet pointé) & : adresse d’une variable

Symboles composés ++ : pré et post incrémentation Opérateurs arithmétiques Opérateurs d’affectation Comparaisons

Symboles composés >> et << : décalage de bits & | ^ : opérateurs de bits Connecteurs logiques : &&, || Expression conditionnelle ? :

Ordre de priorité =>Mettre des parenthèses !!

Exemples x=(7+6)%5/2; x = 10 ; x *= y = z = 4 ; x=1 ; y = x++ ; z = ++x ; x=0;x++;++x; x=y=z=0 ; x += y += 5 * ++ z ; x=y=0;z=2;x = x && y || z ; x = 1 ; y = 3 ; z = ( x < y ? x++ + ++y : 0 ) ;

Exemples x=(7+6)%5/2=((7+6)%5)2=(13%5)/2=3/2; = 1 si x est de type entier = 1.5 si x est de type flottant et / 2.0f y = 4 ; z = 4 ; x = x * 10 ; x=1 ; y = x = 1 ; x++ ; x++ ; z = x =3 ; x=x+1=1;x=x+1=2; z=z+1=1; y = y + 5 * z = 5 ; x = x + y = 5; x=(x && y) || z = 0 || 2 = 1 ; x=x+1=2 ; z = x + y = 5 ; y = y + 1 = 4 ;

Opérations binaires #define SET(nombre, bit) ((nombre) |= (1 << (bit))) #define CLEAR(nombre, bit) ((nombre) &= ~(1 << (bit))) #define GET(nombre, bit) ((nombre) & (1 << (bit)))

Constantes Constantes littérales Entiers : 123 = 0173 = 0x7B Flottants : 3.0e-4f

Tableaux void main() { int t[10] ; int i , min , max ; for (i=0;i<10;i++) scanf ("%d",&t[i]) ; max = min = t[0] ; for (i=1;i<10;i++) if (t[i]>max) max = t[i] ; min = (t[i]<min?t[i]<min:min) ; } printf ("max : %d\nmin : %d",max,min) ;

Tableaux int tab2D[3][2] = { {1,2},{3,4},{5,6} } ;

Structures struct nom {declaration1,...}{var1,...}; Exemple struct Point3d { float x,y,z ; } pt1,pt2 ; struct Point3d pt3 ; Conseil : typdef struct Point3d {…} TypePoint ;

Enumération enum jour_semaine { lundi,mardi,mercredi,jeudi,vendredi,samedi,dimanche } ; typedef enum { FAUX, VRAI } Booleen;

Union ~Structure Mais les champs se superposent => danger union { float reel ; int entier ; } nombre ;

Union nombre.entier = 2 ; nombre.reel = 3 ; nombre.reel : 2.80260e-045 nombre.entier : 2 nombre.reel = 3 ; nombre.reel : 3 nombre.entier : 1077936128 => Privilégier des types de même taille

Union Direct3d :d3d9types.h typedef struct _D3DMATRIX { union { float _11, _12, _13, _14; float _21, _22, _23, _24; float _31, _32, _33, _34; float _41, _42, _43, _44; }; float m[4][4]; } D3DMATRIX;

Préprocesseur #include : Inclure un fichier entête .h : headerfile Différence entre <…> et “…" #define : macros, constantes, labels #ifdef…

#define #define NbLignes 4 #define NbColonnes (NbLignes*2) #define DisplayInt(x) (printf("%d",x))

#ifdef Compilation conditionnelle #ifndef __TEST_H #define __TEST_H … #endif

#ifdef Et aussi: #if #elif #else #ifdef #if defined  #ifdef

Fonctions type identificateur(paramètres) ; type void : aucune valeur retournée

Bibliothèque standard (C ISO) assert.h : macro assert (bogues) complex.h : nombres complexes (C99) ctype.h : traitement de caractères errno.h : gestion des codes d’erreur fenv.h : contrôle de l’environnement en floating point (C99) float.h : gestion des nombres flottants (epsilon…) inttypes.h : conversions précises entre types (Introduit par C99) iso646.h : utilisation du jeu de caractères ISO 646 limits.h : constantes spécifiant les propriétés des types entiers (bornes…) locale.h : gestion des zones (temps…) math.h : fonctions mathématiques courantes setjmp.h : gestion d’instructions goto non locales (~exceptions) signal.h : contrôle de signaux

Bibliothèque standard (C ISO) stdarg.h : gestion de fonctions avec un nombre d'arguments variable stdbool.h : type booléen (entier, #define true 1…) (C99) stdint.h : divers types d'entiers (C99) stddef.h : définition de plusieurs types et macros utiles stdio.h : entrées/sorties (printf, fichiers…) stdlib.h : gestion mémoire, processus, conversions, tri… string.h : manipulation de chaînes de caratères tgmath.h : opérations mathématiques sur des types génériques (C99) time.h : conversion de formats de date et heure wchar.h : manipulation de chaînes à caractères longs wctype.h : classification des caractères longs

Bibliothèque standard Calculs mathématiques #include <math.h> Fonctions sqrt, cos, sin en double précision

Bibliothèque standard Entrées / sorties (I/O) #include «stdio.h» printf( format, arg1, ... ) ; float x = 1.59f, y = 13.2f ; printf( "x=%d, y=%f\n", x, y ); int l ; printf ("Entrez un entier : ") ; scanf("%u",&l); %d , %f , %s , %x , %c...

Bibliothèque standard Fonctions utilitaires #include <stdlib.h> #define __max(a,b) (((a) > (b)) ? (a) : (b)) #define __min(a,b) (((a) < (b)) ? (a) : (b))

Bibliothèque standard Gestion du temps #include <time.h> ((float)clock())/CLOCKS_PER_SEC

Bibliothèque standard #include <time.h> #include <stdio.h> void main( void ) { time_t ltime; time( &ltime ); printf( "The time is %s\n", ctime( &ltime ) ); } The time is Fri Sep 29 12:25:12 2006

Instructions Blocs Tests Boucles Sauts Rupture de séquence If Switch (branchement conditionnel) Boucles For While Do Sauts Break Continue Return Go Rupture de séquence

If if (<condition>) <action 1>; [else <action 2>;]

Switch switch (<condition>) { case <valeur 1> : <action 1>; break; case <valeur 2> : <action 2>; break; … default : <action n>; }

Itération while (<condition>) <actions>; do <actions> while (<condition>); for ([<instructions initiales>];[<condition>];[<instructions>]) [<corps de la boucle>];

Itération séquences for (i=0,j=0;i<10;i++) { ... }

Itération for et while : for (exp1;exp2;exp3) instruction; <=> expr1; while (expr2) { expr3; }

Fonctions type identificateur(paramètres) { /* déclaration des variables */ /* Instructions de la fonction */. /* retour de la fonction */ } Paramètres : type variable [= valeur] [, type variable [= valeur] [...]]

Fonctions Remarques en l'absence de type : int par défaut Avant la norme Ansi : paramètres avant le bloc

Exemple de fonction int AddInt (int nNumber1,int nNumber2) { return (nNumber1+nNumber2) ; } int a = AddInt (4,5) ;

Passage de paramètres En C : uniquement par valeur ! void Incr1(int x) { x = x + 1 ; } void Incr2 (int *x) *x = (*x) + 1 ; utilisation : Incr2 (&x) ;

Nombre variable de paramètres Exemple : int printf( const char *format [, argument]... );

Nombre variable de paramètres type identificateur(paramètres, ...) #include <stdarg.h> int Somme1 (int nCount, ...) { int nResult = 0 ; va_list varg; va_start(varg, nCount); while (nCount!=0) nResult += va_arg(varg, int) ; nCount-- ; } va_end(varg); return nResult;

Exemple int Somme2 (int n1, ...) { va_list varg; int nResult, nValue ; va_start(varg, n1); while( (nValue = va_arg(varg, int)) != 0) nResult += nValue; va_end(varg); return nResult; } int a = Somme1 (3,1,3,7) ; int b = Somme2 (1,3,7,0) ;