GEF 243B Programmation informatique appliquée

1. GEF 243BProgrammation informatique appliquée Définition de types, types énumérés et structures §Apx J, 12.1 – 12.2

2. Revue • Comment est-ce que le nom d’une fonction est similaire au nom d’un tableau? • Je veux déclarer une variable pointeur nommée: fpChar qui pointe à une fonction qui retourne un pointeur à char et prend deux pointeurs à char comme paramètres. • Écrivez votre déclaration ici: JGA Beaulieu

3. Synopsis • Limitation spatiale – Portée (scope) • Limitation temporelle – Durée (extent) • Classe de stockage statique (static) • La définition de type typedef • Les types énumérés • Définition de type énuméré JGA Beaulieu

4. Limitation spatiale – portée (scope) • Nous avons parlé de variables globales et locales au paravent • Ces deux termes réfèrent à la portée d’une variable ou sa limitation spatiale • La portée d’une variable détermine sa visibilité dans l’espace • Où vous pouvez voir et utiliser une variable • La porté d’une variable devrait être la plus petite possible pour être utile: Si une variable n’est pas requise en dehors du bloc, ne la rendez pas visible en dehors du bloc. JGA Beaulieu

5. Limitation spatiale – portée (scope) • La fonction main contient un bloc primaire. • Si une variable est déclaré pardessus ce bloc primaire, alors elle est à la portée de toute l’unité de compilation. Elle est même à la portée de toute autre unité de compilation qui sait qu’elle existe!!! Ne faite pas cela. • Ces variables sont vraiment globales!! • Seulement les définitions de type structure et les définitions de type énuméré devraient être globale à l’unité de compilation. Pas les variables. JGA Beaulieu

6. Portée - Exemple Quelle est la portée des variables et fonctions suivantes? int array[7] = {21, 43, 8, 99, 12}; // Portée de array int max(int x, int y) { return (x>y? x: y); } // Portée de Max int main(void) { int temp; // Portée de temp static int callCount; // Portée de callCount double* newD; // Portée de newD; } JGA Beaulieu

7. Limitation temporelle – Durée (extent) • Donc nous savons ce qu’est la portée; la limitation spatiale d’une variable; son territoire. • Et le temps de vie de la variable lui? • La limitation temporelle d’une variable ou sa durée détermine quand une variable prend vie, qu’elle peut être utilisée et quand elle meurt. JGA Beaulieu

8. Limitation temporelle – Durée (extent) • Les variables existent typiquement pour la durée de l’appel de fonction • Quand la fonction est appelée, un nouvel espace est créé sur la pile du programme pour ses variables • Les variable sont utilisées durant l’exécution de la fonction • Au retour de la fonction, l’espace où ces variables étaient stockées est libéré (le pointeur de pile remonte) et les variables cessent d’exister • Au prochain appel, les variables sont recréées sur la pile (écrasent les anciennes valeurs) JGA Beaulieu

9. Limitation temporelle – Durée (extent) • En déclarant une variable comme static à l’intérieur d’une fonction, la variable est mise sur le segment de données • Elle va sauvegarder la valeur entre les exécutions de la fonction • La variable va seulement mourir à la terminaison du programme • Une variable statique peut être initialisée où elle est déclarée. Elle sera seulement initialisée une fois. • Si vous n’initialisez pas une variable statique sa valeur initiale est zéro. JGA Beaulieu

10. Limitation temporelle – Durée (extent) • Une variable statique est déclarée comme suit: … int Fctn (void) { static int unInt = 0; //init une fois seulement return unInt++; //Ceci va garder le compte //du nombre de fois que la //fonction est appelée. } JGA Beaulieu

11. Limitation temporelle – Durée (extent) • Notez que même si la durée de la variable change en utilisant le mot clé static, la portée ne change pas! • La variable peut seulement être utilisée dans la fonction. JGA Beaulieu

12. Portée et durée • static est une classe de stockage • Jusqu’à date, toutes vos variables ont étés dans la classe de stockage auto; vous n’avez jamais utilisés ce mot clé parce que c’est la classe par défaut • Il y a deux autres classes de stockage (extern et register) mais nous n’étudieront pas ceci dans le cours JGA Beaulieu

13. Durée - Exemple Quelle est la durée des variables et fonctions? int array[7] = {21, 43, 8, 99, 12}; // Durée de array int max(int x, int y) { return (x>y? x: y); } // Durée de Max int main(void) { int temp; // Durée de temp double *newD; // Durée de newD; } int myFunction (void) { static int callCount; // Durée de } // callCount JGA Beaulieu

14. Structures et types dérivés • Jusqu’à date nous avons vue une structure de données: le tableau. • Un tableau a trois caractéristiques: Nom, type et un nombre fixe d’éléments • Une fois déclaré, le tableau peut seulement contenir des éléments du même type. • Nous avons aussi vue deux types dérivés: le tableau et le pointeur. • Ces types sont dérivés parce que ils change les valeurs qu’une variable peut prendre et les opérations définies pour le type de base. JGA Beaulieu

15. Définition de type • Les définitions de type (typedef) sont centrales pour créer des nouveaux types en C • Avec typedef vous pouvez créer un nouveau type à partir d’autres types • Standards ou dérivés • Nous allons voir plus tard aujourd’hui comment typedef nous aide à définir des types de données complexes • Mais nous commençons avec deux exemples simples JGA Beaulieu

16. Définition de type • Vous définissez un nouveau type avec le format de définition de typedef: typedef type IDENTIFICATEUR; Normalement en majuscules Mot clé Tout type de base ou dérivé JGA Beaulieu

17. Définition de type • Même si ce n’est PAS recommandé, vous pourriez définir nouveau type à partir de int en faisant ce qui suit: typedef int INTEGER; • Les deux déclarations qui suivent seraient donc équivalentes: int nombre; INTEGER nombre; JGA Beaulieu

18. Définition de type • Ce qui se fait assez souvent par les programmeurs en C, est d’utiliser typedef pour définir un nouveau type appelé STRING à partir du type pointeur à caractère (char*): typedef char* STRING; … STRING maString;//un pointeur à char • Ceci ferait la même chose que: char* myString; JGA Beaulieu

19. Définition de type • Les deux derniers exemples sont simples, mais ils montrent la flexibilité que C a pour définir de nouveaux types • Dans la syntaxe du langage, n’importe quelle place où vous pouvez placer le nom d’un type standard, vous pouvez utiliser le nom d’une définition de type. • Vous pouvez utiliser les définitions de types dans les déclarations de variables • Déclaration de type de fonctions • Déclaration de paramètres • Opérations de casting,… JGA Beaulieu

20. Types énumérés • Le type énuméré, enum construit par-dessus le type int • Dans un type énuméré, chaque valeur integer est associée avec un identificateur appelé constante d’énumération • Vous avez déjà vue et utilisé quelques types énumérés: • MOTORDIRECTION – OFF, FWD, REV • MOTORPORT – LEFT_MOTOR, RIGHT_MOTOR BOTH_MOTORS JGA Beaulieu

21. Types énumérés • Il y a deux façons de base pour déclarer un type énuméré, mais nous montrons seulement la méthode préférée: //L’énumération propre enum TAG {constantes d’énumération}; //Déclaration d’une variable pour enum enum TAG identificateurDeVar; JGA Beaulieu

22. Types énumérés - exemple • Par exemple si je veux créer un type énumérer pour les mois de l’année, je pourrais faire ceci: enum MOIS {JAN, FEV, MAR, AVR, MAI, JUN, JUL, AOU, SEP, OCT, NOV, DEC}; enum MOIS moisDeNaissance; //déclaration enum MOIS moisDeGrad = MAI; JGA Beaulieu

23. Types énumérés • Notez que parce que les structures de données en C sont basées sur zéro, la valeur du premier élément dans l’énumération est 0 donc JAN = 0 • Mais on peut le faire explicitement: enum MOIS {JAN = 1, FEV = 2,…}; • Si je spécifie seulement la première valeur, le compilateur remplit les prochaines valeurs en additionnant un à chaque item. enum MOIS {JAN = 1, FEV, MAR, AVR,…}; JGA Beaulieu

24. Types énumérés • Deux mises en garde avec les types énumérés. • C permet à deux constantes d’énumération d’avoir la même valeur!! Ceci n’est pas une bonne pratique. enum GRANDEURS {PETIT = 1, GROS = 2, TRES_GROS = 2}; • Il n’y a pas de vérification pour la plage des valeurs d’un type énuméré assigné à une variable: enum GRANDEUR maGrand = 4; //Warning du compilateur JGA Beaulieu

25. Définition de type énuméré • Chaque fois que vous déclarez une nouvelle variable pour votre type énuméré, vous devez utiliser le mot clé enum: enum MOIS moisDeNaissance; • Nous avons appris plus tôt aujourd’hui que nous pouvons renommer un type à quelque chose d’autre; voir plus simple en utilisant typedef JGA Beaulieu

26. Énumération de type définit • Ici nous combinons tout simplement les deux mots clé typedef et enum: typedef enum {ROUGE, BLEUE, JAUNE} COULEURPRIM; COULEURPRIM premiereCouleur = ROUGE; COULEURPRIM deuxiemeCouleur = JAUNE; JGA Beaulieu

27. Quiz Time • Définissez un type énuméré pour les transmissions (manuelle, automatique) • Définissez une énumération de type définit pour la couleur d’une auto JGA Beaulieu