GEF 243B Programmation informatique appliquée

Présentation au sujet: "GEF 243B Programmation informatique appliquée"— Transcription de la présentation:

1 GEF 243B Programmation 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: constant char *(*fpChar) (char *, char *); 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. We talked about information hiding two lectures ago. This concept can extend to hiding your variables inside blocs if they are not needed. Of course pointers can be used to jump across these boundaries. Of course, include, define statements as well as function prototypes will be in global scope. The second bullet is equivalent as having declared a variable as extern in the global section of the compilation unit. 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; } array and max are in scope for the entire compilation unit temp, callCount and newD are in scope for main only 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. Zero for char and int, for float, for pointers. 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 We could mention some of the following, but only if they query us on the storage classes: A global variable by default is an extern variable. If you declare a global variable, heaven forbids, and that you do not want it available to other compilation units, you declare it as static. Some of the code used during the development of the lecture: #include <stdio.h> #include <string.h> #include <stdlib.h> typedef struct { char firstName[15]; char lastName[25]; unsigned long int collegeNumber; float average; } STUDENT; //name of the type int CompareStudents(STUDENT st1, STUDENT st2); void main() STUDENT aMilColStudent = {"Joe", "Shmoe",45239,78.3}; STUDENT bStd = {"Joe", "Shmoe",45239,78.3}; char toto[5] = "hello"; STUDENT *pStudent = &aMilColStudent; if (CompareStudents(aMilColStudent,bStd)) printf("they are the same\n"); aMilColStudent.collegeNumber = 12345; (*pStudent).collegeNumber = 12345; pStudent->collegeNumber = 54321; printf("College Number %d\n", pStudent->collegeNumber); printf("Val of last name %s\n", aMilColStudent.lastName); strcpy(aMilColStudent.firstName, "Bob"); aMilColStudent.collegeNumber = 89876; printf("Val of first name %s\n", aMilColStudent.firstName); // if (aMilColStudent == bStd) printf("ww"); //This produces a compile error aMilColStudent = bStd; printf("College Number %d", pStudent->collegeNumber); //check student is same getchar(); } int CompareStudents(STUDENT st1, STUDENT st2) return (!strcmp (st1.firstName,st2.firstName) && !strcmp (st1.lastName,st2.lastName) && st1.collegeNumber == st2.collegeNumber && (st1.average - st2.average < )); 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 array and max live for the entire run temp and newD live for the execution of main callCount keeps its value between calls to myFunction 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. They should recall that an array is both a data structure (because it organizes data) and a derived type (because with the [] operator and the number of the elements in the array, we change the values and operations that can be done on the basic type. 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 Here we start with typedef, because they are used with both the enumerated types and the structures to define types. We introduce them only as basic definitions. 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 Identifiers for typedefs have normally been written in uppercase letters. This is a good way to tell the person that is reading the code that this is a defined type. Make them understand that we can define ANY kind of new type. 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; This is not recommended, because you are renaming a basic type. We only use this here to show how a type definition is done. There is no point in doing this, because it adds nothing to the readability of the program. Again point to them, the keyword typedef, the type (in this case a basic type) and the identifier in uppercase letters. 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; They should remember that there is no string data type in C, but that some functions are defined in an ad hoc library. It highly depends on the programmer and local coding standards to decide if this kind of type definition is useful or recommended. Here we just want to introduce the concept of typedef. 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 Make them notice that there are two styles here for the name of the constants (lowercase or uppercase). One from brickOS and one from the skeleton. A lot of C programmers prefer to use lowercase inside an enumeration, but we consider that since they are constants, they should be capitalized. 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; Make them notice that there is no = sign like there would be in an array initialization. This could be a mistake because the curly braces are used in both cases. The other way of doing it is by doing the following: enum {enumeration constants} variable_identifier; The problem with this, is every time you want to have a new variable , you must redo the enumeration statement. This can lead to errors if you do not have all the parameters in the same order. 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; Here we could use the blackboard and do an extra few. 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,…}; A good reason to do this, is when people enter the month on the screen of a computer they enter 1 for jan. Although we could have added one to all the mois, this is more robust and less error prone. On the last example, feb = 2, mar = 3,… 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 You will get a warning that states that you are assigning an int to an enumerated type variable. Compiler checked. 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 So we can use this capability to remove the need to use the enum keyword all the time. 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; Remind them of the typedef: typedef type IDENTIFIER 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 enum TRANSMISSIONTYPE {MANUAL, AUTOMATIC} typedef enum {RED, WHITE, YELLOW, GREEN, BEIGE, GREY, BLACK} CARCOLOR; JGA Beaulieu