IFT1969 Programmation scientifique en C Michel Reid.

IFT1969Programmation 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 ( ++ )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émentationnombre-- ; 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

Syntaxeif(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 simplesExpression, habituellement sur une ligne, se terminant par un ;

Ex: total = prix + taxes ;

Instruction structuréeInstruction de contrôle comme if…else, switch ou une

boucle

Bloc d’instructionsPlusieurs 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

Syntaxedo

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 adresseint 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

Syntaxetype 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 programmefor(i = 0; i < 8; i++)

numero[i] = i*2;

– autre exemplefor(i = 0; i < 8; i++)

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éefor(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

– Fermeture du fichier• fclose(aLire);• fclose(aCreer);

Exemple de lectureFILE* aLire;int n = 0;

aLire = fopen("donnees.dat", "r" );while( !feof(aLire)){ fscanf(aLire,"%d%f\n",&num[n],&taille[n] ); n++;}fclose(aLire);

Fichiers de texte

Exemple d’écritureFILE* 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 fichierFILE* aCreer;

aCreer = fopen("resultats.dat", "w" );

if( aCreer == NULL)

{ printf("probleme d’ouverture");

exit(0); …

);

Tableaux à 2 dimensions

Syntaxe#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

| | |

| | |

| | |

------- | |

| | |

----------- --- |

| | |

---------------- ---------------- ----------------




| | | | | | | | | | | | | | | ----------- --- ------- | | | ---------------- ---------------- ---------------- Tour 1 Tour 2 Tour 3


| | | | | | | | | | | --- | | | ----------- | ------- | | | ---------------- ---------------- ---------------- Tour 1 Tour 2 Tour 3



| | | | | | | | | | | --- | | | | ----------- ------- | | | ---------------- ---------------- ---------------- Tour 1 Tour 2 Tour 3


| | | | | | | | | | | | | | | --- ----------- ------- | | | ---------------- ---------------- ---------------- Tour 1 Tour 2 Tour 3



| | |

| ------ |

| | |

--- ----------- |

| | |

---------------- ---------------- ----------------



| | |

| --- |

| | |

| ------ |

| | |

| ----------- |

| | |

---------------- ---------------- ----------------



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)


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);

}

}


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


– Tableau de caractèreschar 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


– Pointeur sur un caractèrechar * 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


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


– 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);


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);


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 :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


– 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


Déclaration de la structure– typedef struct{

int marque;

int modele;

int cassette;

int cd;

int mp3;

float prix;

} radio;


Déclaration d’un tableau de structuresradio 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.


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 {déclarations des champs;

}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

– 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 listestruct Elem * liste;

Ou

Element *liste;

Ou

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• Voir chapitre 12

IFT1969 Programmation scientifique en C Michel Reid.

Documents

Transcript of IFT1969 Programmation scientifique en C Michel Reid.