IFT1969 Programmation scientifique en C Michel Reid

Traitement de l’information Catégorie d’information Les données Les résultats Les informations intermédiaires

Identificateurs Suite de caractères ( lettres, chiffres ou _ ) qui commence par une lettre. Caractères accentués interdits ainsi que #, blanc , ? , …  Seuls les 32 premiers caractères seront significatifs Attention, le C fait la différence entre minuscule et majuscule.

Types de base Entier int Réel float Un caractère char Booléen n’existe pas, une valeur non nulle est considérée vraie, une valeur nulle ou zéro est traitée comme fausse. Chaîne de caractères n’existe pas, on utilise des tableaux de caractères. Autres long, double, etc. Plus tard.

Déclaration d’une variable Une variable est une information dont la valeur peut changer au cours de l’exécution du programme. Syntaxe de la déclaration : type liste de noms de variables de ce type; int le_chiffre; int a, b, le_chiffre;  On peut initialiser la variable à la déclaration int a= 0, b= 10, le_chiffre;

Commentaires En C, un commentaire débute par /* et se termine par */ Un commentaire peut s’échelonner sur plusieurs lignes

Affectation En utilisant l’opérateur = age = 23; a = age;  a = age = 0; La variable située du coté gauche du = représente un contenant, l’endroit où sera déposée la valeur, alors que la variable du côté droit représente la valeur contenu dans la variable.

Affectation élargie Permet de simplifier certaines affectations   A = A + 5;  A += 5; B = B * 3;  B *= 3; A = A / 3;  A /= 3; B = B – 5;  B -= 5;

Conversions implicites à l’affectation Si on affecte un int à un float, conversion de la valeur en float pas de décimale. Un float à un int, valeur est tronquée, seule la partie entière est conservée Un char est considéré comme un entier sur 1 octet (code ASCII) char Lettre; Lettre = 67; /*valide, Lettre vaut le caractère‘C’*/

Opérateurs arithmétiques +, - addition et soustraction * multiplication / division (réelle ou entière) % modulo ( le reste de la division, n’est possible qu’entre 2 entiers )

Opérateurs arithmétiques Si les 2 opérandes sont entières, alors le résultat sera un entier. Si au moins une des 2 opérandes est un réel, le résultat sera un réel. Un caractère, dans une expression, est considéré comme un entier. Ex. la valeur de ‘A’ + 1 est 66 car le code ASCII de ‘A’ est 65.

Incrémentation Post-incrémentation ( ++ ) Pré-incrémentation ( ++ ) nombre++;  nombre = nombre + 1; Lorsque le ++ est placé après son opérande, celle-ci sera incrémenté après son utilisation dans une instruction. Pré-incrémentation ( ++ ) ++nombre;  nombre = nombre + 1; Lorsque le ++ est placé avant son opérande, celle-ci sera incrémenté avant son utilisation dans une instruction.

Décrémentation post-décrémentation Pré-décrémentation nombre-- ;  nombre = nombre – 1; Pré-décrémentation --nombre ;  nombre = nombre – 1;

Opérateurs relationnels == est égale à != est différent de < est inférieur à <= est inférieur ou égale à > est supérieur à >= est supérieur ou égale à Le résultat d’une opération relationnel est 1 (entier) si la relation est vraie, 0 si elle est fausse.

Opérateurs logiques ! le contraire de (non) && et logique || ou logique Le résultat d’une opération logique est 1 si c’est vrai, 0 si c’est faux.

Priorités des opérateurs ( ) - ! Opérateurs unaires, ex, -a !a * / % + - < <= > >= == != && || Dans le cas où les opérateurs ont la même priorité, l’expression est évaluée de gauche à droite.

Constantes 2 façons de déclarer des constantes en C #define identificateur valeur Exemple : #define TPS 0.07 Cette façon est une instruction au compilateur qui recherche identificateur dans les expressions du programme et le remplace par valeur avant la compilation. Très utile pour la déclaration de tableaux. const type identificateur = valeur ; Exemple : const float TPS = 0.07 ; L’affectation ne peut se faire qu’à la déclaration.

printf printf(“format”,liste des valeurs à afficher ); Le format contient le message à afficher avec des codes de formats pour les valeurs que l’on veut faire afficher. Quelques codes de formats %d un entier %f un float, par défaut, l’affichage aura 6 décimales %c un caractère %s une chaîne de caractères

printf Gabarit d’affichage On peut spécifier un nombre minimum de caractères pour écrire une valeur, ainsi qu’une certaine précision. Ex : %6.2f : un réel à 2 décimales, la valeur de la seconde décimale sera arrondi au besoin, un point décimal et 3 caractères pour la partie entière. Si la partie entière ne peut s’afficher sur 3 caractères, printf utilisera le nombre d’espaces nécessaires. %4d un entier affiché sur au moins 4 caractères, plus si la valeur est supérieur à 9999 Dans ces 2 cas, si la partie entière est plus petite que le nombre minimum de caractères, les caractères additionnels seront des espaces placés à la gauche de la valeur.

scanf scanf(“format”,liste des adresses de variables à lire); Les codes de formats sont les même que pour printf L’utilisation de gabarit n’est pas souhaitable Ex: : scanf(“%d %f”, &unEntier, &unFloat); En cas d’incompatibilité entre le format et la valeur lue, scanf s’interrompt et certaines des variables auront conservées leur ancienne valeur. Si un nombre insuffisant de valeur est tapé au clavier, scanf attend que toutes les valeurs soient saisies ou bien de rencontrer une erreur avant de s’arrêter. Toute valeur additionnelle est conservée dans la zone tampon du clavier.

Instructions de contrôle if…else Syntaxe if(condition) Instruction1 else Instruction2 La condition est une expression dont la valeur, si elle est non-nulle est considéré comme vrai, dans ce cas l’instruction1 est exécutée. Sinon, l’instruction2 est exécutée. Le else est facultatif Instruction1 et instruction2 sont soit des instructions simples, structurés ou encore composés (blocs d’instructions)

Instructions de contrôle if…else Instructions simples Expression, habituellement sur une ligne, se terminant par un ; Ex: total = prix + taxes ; Instruction structurée Instruction de contrôle comme if…else, switch ou une boucle Bloc d’instructions Plusieurs instructions simples ou structurées entre { et } { taxes = prix * taux; total = prix + taxes; }

Instructions de contrôle switch Cas particulier du if lorsque l’on test plusieurs valeurs (entières ou caractères) qui sont mutuellement exclusives switch(unChiffre) { case 1 : a = b + c; break; case 2 : a = b * c; Break; default : a = b / c; }

Instructions de contrôle switch unChiffre est une valeur entière ou caractère Le case sert à indiquer le point d’entrée dans le switch si unChiffre a cette valeur. À partir du point d’entrée, toutes les instructions suivantes sont exécutées jusqu’à l’occurrence d’un break ou de la fin du switch. Le default est facultatif, s’il est présent, c’est le point d’entrée de toutes les valeurs qui ne sont pas spécifiées dans un case. La valeur d’un case ne peut être un intervalle.

Instructions de contrôle boucle do…while Syntaxe do instruction while(condition); L’instruction peut être simple, structurée ou un bloc. Si la condition est vraie, l’instruction de la boucle est ré-exécutée. L’instruction sera exécutée au moins une fois.

Instructions de contrôle boucle while Syntaxe while(condition) instruction L’instruction peut être simple, structurée ou un bloc. Si la condition est vraie, l’instruction de la boucle est exécutée. La condition est évaluée au début de la boucle, donc il est possible que l’instruction dans la boucle ne soit jamais exécutée.

Instructions de contrôle boucle for Syntaxe for(expr1; expr2; expr3) instruction L’instruction peut être simple, structurée ou un bloc. expr1: initialisation avant la 1ière itération. expr2: condition qui est évaluée avant chaque itération. expr3: instruction effectuée à la fin de chaque itération incrémentation, décrémentation, etc.

Adresse On utilise très souvent les adresses dans : la saisie des données avec scanf  les appels des fonctions pour recevoir des valeurs retournées L’adresse (son emplacement en mémoire) d’une variable est accessible par l'opérateur & (adresse de) ex : scanf((“%d”,&unEntier); scanf a besoin de l’adresse en mémoire de la variable unEntier pour y placer la valeur lue

Taille d’un emplacement en mémoire Pour connaître la taille d’un emplacement en mémoire, nous utilisons la fonction sizeof( ); Le paramètre passé est soit un type, soit une variable Le résultat retourné est le nombre d’octets nécessaire pour stocker une valeur de ce type sizeof(char); /* retourne 1 */ sizeof(unEntier); /* retourne 4 si unEntier est déclarer int */

Pointeurs On utilise des pointeurs dans : La transmission des arguments par pointeurs (résultats de retour) La manipulation des tableaux Les fichiers : FILE * aLire, * aCreer Les chaînes de caractères Les structures de données dynamiques (liste linéaire chaînée, arbre binaire, ...)  Etc.

Pointeurs (suite) Un pointeur est une variable dont la valeur est une adresse  Déclaration : type * identificateur ; ex: int *pointeurSurEntier ; PointeurSurEntier est une variable qui peut contenir l’adresse mémoire d’une variable entière int unEntier, *pointeur = &unEntier; La valeur d’un pointeur étant une adresse, l’opérateur * permet d’accéder à la valeur qui est à cette adresse int unEntier = 5,unAutre, *pointeur = &unEntier; unAutre = *pointeur;/* unAutre prend la valeur 5 */

Fonctions Le seul type de sous-programme qui existe en C est la fonction Syntaxe type nomDeFonction( liste de paramètre(s)) { déclarations locales si nécessaire traitement et retour (avec return) du résultat } En C, la fonction doit être déclarée avant toute appel à celle-ci.

Fonctions (suite) Déclarations : prototype : float plusGrand( float, float, float); définition : float plusGrand(float val1, float val2, float val3) { float grand; if(val1>val2) grand = val1; else grand = val2; if(grand > val3) return grand; else return val3; } Appel : plusG = plusGrand( taille1, taille2, 2.15);

Fonctions (suite) Dans la déclaration, chaque paramètre doit être précédé de son type À l’appel, seuls les noms de paramètres sont écrits Par défaut, seul une copie de la valeur est passée en paramètre La correspondance entre les paramètres de l’appel et de la fonction dépend de la position dans la liste des paramètres Les variables locales et les copies locales des paramètres n’existent plus lorsque l’exécution de la fonction est terminée

Fonctions naturelles (avec return) L’appel de la fonction « vaut » le résultat retourné La valeur retournée est celle placée à droite de l’instruction return qui est exécutée ex: return 0; /* retourne la valeur 0 (faux) */ Une fonction ne peut retourner qu’une seule valeur avec return L’exécution du return provoque la fin de la fonction L’appel d’une fonction naturelle peut être placée n’importe où une valeur est valide : printf, côté droit d’une affectation, paramètre de fonction, condition, etc.

Fonctions void Équivalent à une procédure dans les autres langages Ne retourne pas de valeur L’utilisation de return est possible mais sans placer de valeur. Cette instruction va terminer l’exécution de la fonction Utile lorsque l’on veut faire un traitement qui ne produit pas de nouvelle valeur ex : Affichage, trie. etc.

Fonctions, arguments transmis par pointeurs Rappel : la valeur d’un paramètre n’est qu’une copie dans la fonction, tout changement de cette valeur sera perdu à la fin de la fonction Si nous passons une adresse en paramètre, la fonction reçoit une copie de cette adresse, par contre, la case mémoire « pointer » par cette adresse sera encore valide après la fin de la fonction Donc il y a moyen de transmettre un résultat autrement qu’avec return

Fonctions, arguments transmis par pointeurs void litValeur(int *valALire1, int *valALire2) { int tempo1, tempo2; printf(" Entrez 2 entiers" ); scanf(" %d%d" , &tempo1 , &tempo2); *valALire1 = tempo1; *valALire2 = tempo2; } Cette fonction transmet 2 résultats par pointeurs L’appel : litValeur( &unEntier1, &unEntier2);

Tableaux Déclaration : type nom[ taille du tableau ]; int numero[32]; float salaire[32]; Le type est le même pour chaque élément du tableau En C standard, la taille du tableau doit être exprimé avec un chiffre pour pouvoir compiler #define MAX_ELEM 32 float salaire[MAX_ELEM]; On ne peut utiliser const pour la taille du tableau

Tableaux Le compilateur va réserver taille de tableau * taille du type espaces contiguës en mémoire Le nom du tableau est une constante qui vaut l’adresse du premier élément Les indices d’un tableau vont de 0 à MAX_ELEM – 1 Chaque élément du tableau est une variable Pour accéder à un élément en particulier, suffit de spécifier son indice. Ex : numero[3] correspond au 4ième élément du tableau numero

Tableaux Initialisation Un tableau peut être initialisé à la déclaration int numéro[8] = { 2, 4, 6, 8, 10, 12, 14, 16} ; L’initialisation peut aussi avoir lieu durant l’exécution du programme for(i = 0; i < 8; i++) numero[i] = i*2; autre exemple scanf("%d", &numero[i]);

Tableaux Manipulation Il est important de connaître le nombre d’élément effectif dans le tableau int numéro[MAX_ELEMENT]; int nbElement; Pour un traitement sur l’ensemble du tableau, la boucle for est toute indiquée for(i = 0; i < nbElement; i++) traitement

Tableaux Manipulation Il est important de connaître le nombre d’élément effectif dans le tableau int numéro[MAX_ELEMENT]; int nbElement; Pour un traitement sur l’ensemble du tableau, la boucle for est toute indiquée for(i = 0; i < nbElement; i++) traitement

Tableaux Tableau comme paramètre de fonction Lorsque un tableau est passé en paramètre d’une fonction, ce n’est pas une copie qui est passée mais bien le tableau À la déclaration : int nbPair ( int numero[], int n) Ou encore : int nbPair ( int *numero, int n) À l’appel : paires = nbPair(numero, nbElement);

Tableaux Manipulation avec pointeurs Le nom du tableau contient l’adresse du premier élément *(T+i)  T[i] T+i  &T[i]

Fichiers de texte Syntaxe Déclaration d’un pointeur sur un fichier FILE * aLire, *aCreer; Ouverture aLire = fopen("nom du fichier", "r" ); aCreer = fopen("nom du fichier", "w" ); Lecture while(!feof(aLire) fscanf(aLire, format, liste d’adresses); Écriture fprintf(aCreer, format, liste de valeurs);

Fichiers de texte Exemple de lecture Fermeture du fichier fclose(aLire); fclose(aCreer); Exemple de lecture FILE* aLire; int n = 0; aLire = fopen("donnees.dat", "r" ); while( !feof(aLire)) { fscanf(aLire,"%d%f\n",&num[n],&taille[n] ); n++; }

Fichiers de texte Exemple d’écriture FILE* aCreer; int n = 0; int numero[20], nbNumero,i; float taille[20]; aCreer = fopen("resultats.dat", "w" ); … for(i = 0; i < nbNumero; i++) { fprintf(aCreer,"%4d %6.2f\n", numero[i], taille[i]); } fclose(aCreer);

Fichiers de texte Pour vérifier l’ouverture du fichier FILE* aCreer; aCreer = fopen("resultats.dat", "w" ); if( aCreer == NULL) { printf("probleme d’ouverture"); exit(0); … );

Tableaux à 2 dimensions Syntaxe Manipulation #define BORNE1 25 #define BORNE2 5 type nomDuTableau[BORNE1][BORNE2]; Si on considère un tableau à 2 dimensions comme une matrice, le premier indice représente les lignes et le second, le nombre de colonne. Manipulation Double boucles for Dans l'en-tête d'une fonction, il faut donner au moins la deuxième borne, ex :  void afficher( float note [][NB_NOTES], int nbEtud) ;

Récursivité Une fonction est récursive si elle s'appelle elle-même.  exemple : int factoriel ( int n ) { if ( n <= 1 ) return 1 ; else return n * factoriel(n-1) ; }

Récursivité Écriture d’une fonction récursive. Trouver une condition d’arrêt, c’est-à-dire, un cas où la solution est triviale. Pour le problème non trivial, trouver le moyen de ramener ça à un problème d’ordre inférieur de façon à ce que le problème avec la solution triviale puisse être atteint.  

Récursivité Le calcul du factoriel est définie comme suit : n! (n factoriel) = 1 si n = 0 ou n = 1 = n * (n-1)! Sinon Donc, si n = 0 ou 1, la solution est triviale. Si n > 1, on peut ramener le problème au niveau n-1  

Récursivité : Fibonacci Un autre exemple classique de récursivité est la suite de Fibonacci : Elle est définie comme suit :   f(1) = 1 f(2) = 1 f(3) = 2 f(4) = 3 f(5) = 5 f(6) = 8 f(7) = 13 etc ...

Récursivité: Fibonacci et Hanoï Définition mathématique de Fibonacci : | 1 pour n = 1 et n = 2 (convention) f(n) = | | f(n-1) + f(n-2) pour n =3, 4, 5, 6, ... | (somme des deux derniers termes) Les tours de Hanoï Supposons qu'on dispose de 3 disques à la tour 1 et on aimerait les déplacer à la deuxième tour en utilisant la tour 3 comme intermédiaire.   Les règles du jeu sont les suivantes : les disques ont un diamètre différent on déplace un disque à la fois on n'a pas le droit de placer un disque de diamètre supérieur sur un de diamètre inférieur.

Récursivité: Tours de Hanoï étape 0 : | | | --- | | ------- | | ----------- | | ---------------- ---------------- ---------------- Tour 1 Tour 2 Tour 3 étape 1 : déplacer un disque de Tour 1 à Tour 2 ----------- --- |

Récursivité: Tours de Hanoï étape 2 : déplacer un disque de Tour 1 à Tour 3 | | | ----------- --- ------- ---------------- ---------------- ---------------- Tour 1 Tour 2 Tour 3 étape 3 : déplacer un disque de Tour 2 à Tour 3   | | --- ----------- | -------

Récursivité: Tours de Hanoï étape 4 : déplacer un disque de Tour 1 à Tour 2   | | | | | --- | ----------- ------- ---------------- ---------------- ---------------- Tour 1 Tour 2 Tour 3 étape 5 : déplacer un disque de Tour 3 à Tour 1 --- ----------- -------

Récursivité: Tours de Hanoï étape 6 : déplacer un disque de Tour 3 à Tour 2   | | | | ------ | --- ----------- | ---------------- ---------------- ---------------- Tour 1 Tour 2 Tour 3 étape 7 : déplacer un disque de Tour 1 à Tour 2 | --- | | ----------- |

Récursivité: Tours de Hanoï Avec une fonction récursive : void deplacer (int n, int t1, int t2, int t3) { if ( n == 1 ) printf("De la tour %d à la tour %d\n", t1, t2) ; else { deplacer (n-1, t1, t3, t2) ; deplacer ( 1 , t1, t2, t3) ; deplacer (n-1, t3, t2, t1) ; }

Récursivité: QuickSort Supposons qu'on dispose du tableau t qui contient les 9 éléments suivants à trier : t[0] t[1] t[2] t[3] t[4] t[5] t[6] t[7] t[8] ╔═════╗═════╗═════╗═════╗═════╗═════╗═════╗═════╗═════╗ ║ 43 ║ 75 ║ 23 ║ 46 ║ 55 ║ 12 ║ 64 ║ 77 ║ 33 ║ ╚═════╝═════╝═════╝═════╝═════╝═════╝═════╝═════╝═════╝  On trouve la position de 43 et on partitionne t[0] t[1] t[2] t[3] t[4] t[5] t[6] t[7] t[8] ╔═════╗═════╗═════╗═════╗═════╗═════╗═════╗═════╗═════╗ ║ 12 ║ 33 ║ 23 ║ 43 ║ 55 ║ 46 ║ 64 ║ 77 ║ 75 ║ ________________ ^ _____________________________ valeurs <= 43 | valeurs > 43 | valeur du pivot (43 trouve sa bonne place à l'indice du pivot 3)

Récursivité: QuickSort La valeur du pivot étant dans sa position finale, il nous reste 2 sous-tableaux à trier Fonction quickSort : void quickSort (int t[], int gauche, int droite)  { int indPivot ;   if (gauche < droite) { partitionner (t, gauche, droite, &indPivot); quickSort(t, gauche, indPivot - 1 ); quickSort(t, indPivot+1, droite); }

Récursivité: QuickSort Fonction partitionner : void partitionner(int t[], int debut, int fin, int * indice) { int g = debut , d = fin ; int valPivot = t[debut];   do { while (g <= d && t[g] <= valPivot) g++ ; while (t[d] > valPivot) d-- ; if (g < d) echanger(&t[g], &t[d]); } while (g <= d );   echanger(&t[debut], &t[d]); *indice = d ; }

Allocation dynamique de mémoire Jusqu’à présent, pour stocker un grand nombre de données nous avons utilisé des tableaux. Mémoire statique Taille du tableau est fixe Nous devons nous assurer de déclarer le tableau d’une taille suffisante. Gaspillage d’espace mémoire Structure non adaptive

Allocation dynamique de mémoire Nous avons brièvement discuté de tableaux dynamique Rappel : les instructions nécessaires pour créer un tableau dynamique de 100 entiers sont : #include<stdlib.h> int * tab; tab = (int *)malloc(100 * sizeof(int)); Dans ce cas, la différence avec un tableau statique est le moment de l’allocation de la mémoire (à l’exécution)

La fonction malloc( ) La fonction est déclarée dans stdlib.h comme suit : void * malloc(unsigned size); Le paramètre size correspond au nombre d’octets de mémoire à allouer La fonction retourne l’adresse en mémoire du début du bloc de size octets Le type de retour étant un pointeur sur void, nous devons utiliser un type cast ( ) pour forcer un changement de type à l’affectation Pour libérer la mémoire, il faut utiliser free(ptr); où ptr est l’adresse en mémoire du début du bloc

Chaîne de caractères En C, il n’y a pas de type de base pour représenter une chaîne de caractères. 2 façons Tableau de caractères Pointeur vers un caractère

Chaîne de caractères Tableau de caractères char salutation[8] ; /* il faut laisser de la place pour \0 */ strcpy(salutation, "bonjour"); strcpy (string copy) est utilisé pour faire une affectation a une chaîne de caractères | ‘b' | ‘o‘ | ‘n' |‘j’ | ‘o' | ‘u‘ | ‘r' |‘\0’| |_____|_____|_____|____|_____|_____|_____|____| Le ‘\0’ marque la fin de la chaîne de caractères Comme c’est un tableau, son nom est une constante donc, salutation = "bonjour"; n’est pas valide

Chaîne de caractères Opérations sur des chaînes de caractères Pointeur sur un caractère char * salutations; salutations = "bonjour"; strcpy(salutation, "bonjour"); Opérations sur des chaînes de caractères Le nom d’une chaîne est un pointeur, donc les opérations arithmétiques, de comparaison et logiques se font sur une adresse

Chaîne de caractères Fonctions de la librairie string.h strcpy(ch1, ch2); Copie le contenu de la ch2 dans ch1 strcmp(ch1, ch2); Retourne une valeur < 0 si ch1 est plus petit que ch2 en ordre alphabétique = 0 si ch1 et ch2 sont identique (même contenu) > 0 si ch1 est plus grand que ch2 en ordre alphabétique strlen(ch1); Retourne le nombre de caractères de ch1 avant le ‘\0’ strcat(ch1, ch2); Concatène le contenu de ch2 à la fin de ch1

Chaîne de caractères Pour imprimer une chaîne à l’écran strchr (ch1, car1); Retourne l’adresse de la première occurrence du caractère car1 dans la chaîne ch1, NULL si car1 n’y est pas strupr(ch1); ch1 est transformée en majuscule strlwr(ch1); ch1 est transformée en minuscule Pour imprimer une chaîne à l’écran printf ("%s",ch1);

Chaîne de caractères Lecture au clavier d’une chaîne de caractères scanf(" %s ", adresse du début de la chaîne); Va saisir une chaîne jusqu’à un séparateur. gets(adresse du début de la chaîne); Va saisir jusqu’au retour de chariot (‘\0’) Lecture d’une chaîne dans un fichier fscanf(pointeur sur un fichier," %s ", adresse du début de la chaîne); fgets(adresse du début, nombre de caractères à lire +1, pointeur sur un fichier);

Chaîne de caractères Trucs pour le traitement des chaînes de caractères Si vous connaissez l’algorithme pour des entiers, vous pouvez l’appliquer à des chaînes de caractères en effectuant les changements suivants : a = b ; strcpy(ch1,ch2); if(a == b) if(strcmp(ch1,ch2) == 0) if(a <= b) if(strcmp(ch1,ch2) <= 0) …

Structure C'est une collection des champs pour des données qui peuvent être de types différents. Syntaxe : struct nom { déclarations des champs; }; Dans ce cas, struct nom devient un nouveau type Le nom est facultatif, quoique sans nom, nous ne pouvons pas déclarer de variable de ce type

Structure Autre syntaxe possible : Déclarations des champs typedef struct { déclarations des champs; }nom; Dans ce cas, nom devient un nouveau type Déclarations des champs Chaque champ est déclaré avec son type et le nom du champ

Structure Accès à un champ d’une structure Si personne est une variable de type structure personne.taille accède au champ taille de cette variable Si pers est un pointeur sur une variable de type structure pers->taille accède au champ taille de la variable pointée par pers

Tableau de structures Justification Supposons que nous avons beaucoup d’informations se rapportant à un même objet et que nous devons traiter plusieurs de ces objets. int marque[MAX]; int modele[MAX]; int cassette[MAX]; int cd[MAX]; int mp3[MAX]; float prix[MAX]; En utilisant un tableau pour chaque information, on obtient 6 tableaux

Tableau de structures L’utilisation de tableaux à 2 dimensions peut diminuer un peu le nombre de tableaux à gérer int marque[MAX]; int modele[MAX]; int options[MAX][3]; float prix[MAX]; On obtient ainsi 4 tableaux Il serait intéressant de pouvoir contenir toute l’information dans un seul tableau

Tableau de structures Déclaration de la structure typedef struct{ int marque; int modele; int cassette; int cd; int mp3; float prix; } radio;

Tableau de structures Déclaration d’un tableau de structures Avantages radio tabRadio[MAX]; Cette déclaration réserve de l’espace pour MAX variables de type radio. Avantages Un seul tableau à passer en paramètre à des fonctions Ce prête bien à l’utilisation de fichiers binaires.

Tableau de structures Désavantage On ne peut plus passer un tableau contenant une seule information Les fonctions qui doivent faire un traitement sur une information en particulier de la structure doivent gérer l’accès à celle-ci. En particulier si le traitement est le même mais pour 2 champs différents de même types. Ex: une fonction qui compte et retourne le nombre de radios ayant une option donnée.

Structure (rappel) L’utilisation d’une structure permet d’avoir plusieurs champs de données de types différents pour un seul élément Déclarations : struct nom { déclarations des champs; }; Ou typedef struct { }nom; Il est possible d’avoir un tableau dynamique de structures

Listes chaînées Une liste chaînée est une structure de données qui a l’avantage de s’adapter facilement aux besoins en espace mémoire. Schéma d’une liste chaînée ╔═════╗════╗ ╔═════╗════╗ ╔═════╗════╗ liste ---->║ 20 ║ ------->║ 15 ║ ----->║ 10 ║ X ║ ╚═════╝════╝ ╚═════╝════╝ ╚═════╝════╝ Un élément d’une liste est une structure qui contient une portion informations et un champs pointeur sur un autre élément du même type de structure La tête de la liste est un pointeur (ici liste) qui pointe sur le premier élément de la liste

Listes chaînées Exemple de déclaration de la structure d’un élément Chaque élément de la liste sait où est le suivant grâce à son champs qui est un pointeur (souvent nommé suivant) Le champs pointeur (suivant) du dernier élément de la liste vaut NULL Seul liste sait ou débute la liste Exemple de déclaration de la structure d’un élément typedef struct Elem { int valeur ; struct Elem * suivant ; } Element ; Ici struct Elem est nécessaire car à l’intérieur de la déclaration des champs, le type Element n’est pas connu

Listes chaînées Déclaration de la liste struct Elem * liste; Ou Element *liste; typedef Element * Pointeur; Pointeur liste; liste est un pointeur sur un élément (le premier) de la liste chaînée

Listes chaînées Parcourir tous les éléments d’une liste while(liste != NULL) { traitement sur l’élément courant liste = liste->suivant; } while(liste != NULL) peut être remplacé par while(liste)

Listes chaînées Dans le cadre de ce cours, nous allons voir 2 sortes de listes chaînées LIFO (Last In First Out) qui peut être vue comme une pile Voir chapitre 12 FIFO (First In First Out), une file d’attente