Service D'Informatique - Université De Mons
FACULTE POLYTECHNIQUE DE MONSService d’Informatiqueet Programmation ObjetMohammed Benjelloun2ème BachelierAnnée académique 2008-2009
Table des --------------------------------------------- 1Chap 1 : Les structures et fonctions membres ---------------------------------------- 31.1. Principes des --------------------------------------------31.2. Structures et fonctions membres -----------------------------------6ExercicesChap 2 : Les listes simplement ------ 72.1. Généralités 2.2. Listes Simplement chaînées ap3 : Les Classes ---------------123.1. Classes et ------------------------------------------------ 123.2. Concept d’encapsulation ------------------------------ 133.3. Création ------------------------------------------------- 143.4. Affectation d’objets ------------------------------------- 163.5. Déclaration d’une fonction membre --------------- 163.6. Notions de constructeur et de destructeur -------- 203.6.1.3.6.2.3.6.3.3.6.4.Constructeurs par défaut ---------------------------------------- 21Constructeur de copie -------------------------------------------- 27Listes d’initialisation des constructeurs ----------------------- 29Affectation d’un objet par un autre de la même classe ------- 293.7. Tableau d’objets ----------------------------------------- 303.8. Surcharge des ----------------------------------------- -----------Exercices34Chap4 : Les patrons et amis -------364.1. Patrons de fonctions ------------------------------------ 364.2. Classe template : patron de classes ----------------- 374.3. Utilisation d’un patron de -------------------------- 39M.BENJELLOUNInfo IIS. Informatique
4.4. Fonctions et classes ---------------------------------- 414.4.1. Fonctions amies - 424.4.2. Méthodes ------- 424.4.3. Classes amies ---- -----------44ExercicesChap5 : L'héritage -----------------455.1. Classes de base et classes ---------------------------- 455.2. Mode de dérivation ------------------------------------- 455.3. Héritage ------------------------------------------------- 465.4. Redéfinition de membres dans la classe dérivée ------------------------------------------------- 495.4.1. Redéfinition des fonctions membres ---------------------------- 495.4.2. Redéfinition des données membres ------------------------------ 505.5. Héritage et -------------------------------------- 505.6. Polymorphisme ------------------------------------------ -----------54ExercicesChap6 : La bibliothèque ---------586.1. --------- 586.2. Les ---- 586.2.1. ------------------- 596.2.2. List ---------------- 606.3. Les ------- 606.4. Les algorithmes ------------------------------------------ -----------68ExercicesSyllabus2d 2 : Transparents des séances d’exercicesM.BENJELLOUNInfo IIS. Informatique
Avant-proposCes notes constituent le support des travaux pratiques et des exercices dans le cadre del'enseignement du cours d'Informatique II de la deuxième année de bachelier à la FacultéPolytechnique de Mons. Il représente aussi une partie du cours Programmation etAlgorithmique dispensé aux étudiants d’IG Charleroi. Lors des séances d'exercices, où laprésence est obligatoire, un complément de matière sera abordé. Donc le présentdocument ne peut être considéré comme complet.Ce cours s’appuie sur des notions préliminaires de programmation procédurale. La syntaxedu langage C ainsi que les notions fondamentales de programmation ont été étudiéesdurant le cours d’Informatique I et sont supposées acquises.Durant ce cours, les notions fondamentales de la programmation orientée objet sontabordées. Nous commençons par un rappel sur les structures auxquelles nous introduisonsles fonctions membres. Le chapitre 2 peut être considéré comme une brève introductionaux listes simplement chaînées dont le rôle est de remédier aux limitations des tableauxstatiques ou dynamiques. Avec le chapitre sur les classes, généralisation de la notion detype défini par l'utilisateur, nous abordons véritablement les possibilités de"programmation (orientée) objets". Nous introduisons la définition d’une classe, la notionde méthode, l’encapsulation et le type de membre (publique, privé, protégé), ainsi que lesnotions très importantes de constructeur et de destructeur indispensables à ce type deprogrammation. Nous montrons aussi comment définir une famille de fonctions ou declasses paramétrées par un ou plusieurs types grâce à la notion de patron de fonctions etde classes.Par la suite nous proposons un principe propre à la programmation orientée objet :l'héritage qui permet de créer une nouvelle classe à partir d'une classe existante. Un autreconcept des langages objet qui découle directement de l'héritage est le polymorphisme.Pour terminer, nous esquissons la bibliothèque STL (Standard Template Library :Bibliothèque standard générique.) qui est certainement l’un des atouts de C et qui peutêtre considérée comme un outil très puissant.Comme la programmation par l’exemple vaut mieux que tous les beaux discours, nous avonsillustré et agrémenté ces notes, comme les Slides des séances d'exercices, de nombreuxprogrammes permettant à l’étudiant d’assimiler les principales notions présentées. Tous lesprogrammes sont fournis complets avec le résultat de leur exécution. Le code source deces programmes est accessible sur le site Web de la Faculté. Nous ne pouvons qu’insistersur la quasi-nécessité de les tester, et mieux encore de les comprendre et de les modifier.En ce qui concerne les exercices, nous incitons l’étudiant à les programmer, car laprogrammation est un art qui s’apprend en pratiquant.Vous l’aurez compris, ces notes n’ont pas la prétention d’expliquer en détail tous lesconcepts du C , mais se proposent en tant qu’introduction à la programmation orientéeobjet. Ce syllabus ne peut donc être considéré comme autosuffisant pour apprendre tout le
2langage C . En effet, la matière est vaste et le temps attribué est court. Mais laprogrammation orientée objet, sera approfondie durant le cours de 3ème année enpréparation au master d’Informatique et Gestion.Nous renvoyons, néanmoins le lecteur désireux d'en savoir plus à l'un des très nombreuxouvrages de référence sur le C , notamment à:Claude Delannoy Programmer en langage C , Eyrolles, 2004 ou l’édition 2007Très bon livre pour commencer le C , livre très pédagogique et assez complet.Plusieurs chapitres sont dédiés aux composants de la bibliothèque standard du C .John R. Hubbard Programmer en C , Collection Schaum‘s Ediscience, Dunod 2002.Un ouvrage expliquant les concepts de base de la programmation C à l'aided'exemples. On y trouve entre autre: Classes, Surcharge d'opérateurs, Compositionet héritage, Modèles et itérateurs, C standard et les vecteurs, Classes conteneur.John R. Hubbard Structures de données en C , Collection Schaum‘s Ediscience,Dunod 2003.Ce volume est complémentaire au précédent. Près de 455 exercices et problèmesrésolus sont décortiqués pour une meilleure compréhension. On y trouve entre autre :Classes, Listes, Tables, Arbres, classes conteneurs standard, algorithmes génériques.Sur le Web : http://cpp.developpez.com/cours/cpp/Cours, tutoriels, livres électroniques et Docs sur C Mega Cours C en françaisJe voudrais remercier ici les collègues du Service d'Informatique qui ont pris soin derelire ces notes et de suggérer corrections et améliorations. Je suis bien conscient qu'ilreste des erreurs et/ou des imprécisions. Merci au lecteur assidu de les signaler!Si vous notez la moindre erreur ou si vous souhaitez me proposer vos suggestions,n'hésitez pas à le faire à l’adresse E-mail suivante :Mohammed.Benjelloun@fpms.ac.beM. BENJELLOUNInfo IIS. Informatique
Chap 1 : Les structures et fonctions membresCe chapitre est un prolongement du chapitre 8 du syllabus de la 1ère année de bachelier surl'utilisation des structures en C . Certaines notions du chapitre 8 vont être rappelées ici,brièvement ; d'autres, complètement nouvelles comme les fonctions membres, serontintroduites.1.1. Principes des structuresUne structure est un ensemble de variables (de types éventuellement différents),définissant un nouveau type sous un seul nom, adapté à une gestion spécifique et à unemanipulation facile des données.Une structure se définit par un identificateur suivant le mot-clé struct, ainsi que par uneliste de champs ou membres définis par un identificateur d'un type donné. Par exemple,pour gérer les coordonnées d'un point (abscisse et ordonnée) ou des étudiants, on pourradéfinir les types suivants :struct point {int x;int y;};struct Etudiant {int Id;string Nom;};Quant à x et y, on dit que ce sont des champs ou des membres de la structure point, alorsque Nom et Id sont des champs de la structure Etudiant.On déclare ensuite des variables du type point (Etudiant) par des instructions telles que :struct point a, b;struct Etudiant Etud1, Etud2;Etudiant Etud[10] ;// a et b deux variables de type structure point// Etud est un tableau de 10 éléments de type structure EtudiantCelle-ci réserve l'emplacement pour des structures nommées a et b de type point, Etud1et Etud2 de type Etudiant et finalement un tableau de 10 éléments de type Etudiant.L'accès aux membres de a, b ou de Etud1 et Etud2 se fait à l'aide de l'opérateur point(.). Par exemple, a.y désigne le membre y de la structure a et Etud1.Nom désigne le nomdu Etudiant Etud1.RqEn C le mot clé struct n'est pas nécessaire devant la structure lors de la déclaration.En C , nous allons pouvoir, dans une structure, associer aux données constituées par sesmembres des méthodes qu'on nommera "fonctions membres".
Chap 1 : Les structures et fonctions membres41.2. Structures et fonctions membresSupposons qu’en plus de la déclaration des données Id et Nom, nous souhaitions associer àla structure Etudiant deux fonctions : void Saisie() : pour saisir l’identifiant et le nom d’un seul Etudiant ; void Affiche() : pour afficher les information d’un seul Etudiant.Voici comment nous pourrions éventuellement déclarer la structure Etudiant :struct Etudiant {int Id;string Nom;void Saisie() ;void Affiche() ;};Dans la déclaration d'une structure, il est permis (mais généralement peu conseillé)d'introduire les données et les fonctions dans un ordre quelconque (nous avonssystématiquement placé les données avant les fonctions).Le programme suivant reprend la déclaration du type Etudiant, la définition de sesfonctions membres et un exemple d’utilisation dans la fonction main :#include iostream #include string using namespace std ;struct Etudiant {int Id;string Nom;void Saisie() ;// Saisir un élémentvoid Affiche() ;};// ----- Définition des fonctions membres du type Etudiant ---void Etudiant::Saisie() {cout "donnez un identifiant : ";cin Id;cout "donnez un nom : " ;cin Nom;}void Etudiant::Affiche() {cout "Identifiant " Id endl;cout "Son nom : " Nom endl;}void main(){Etudiant Etud3, Etud[3];cout "---- Etud012 ---- " endl;for(int i 0 ; i 3 ; i ){Etud[i].Saisie();Etud[i].Affiche();}cout "---- Etud3 ---- " endl;Etud3.Saisie();// accès à la fonction Saisie du Etudiant Etud1Etud3.Affiche();}Programme 1.1.M. BENJELLOUNInfo IIS. Informatique
Chap 1 : Les structures et fonctions membresSOLUTION5---- Etud012 ---- donnez un identifiant : 0donnez un nom : Etud0Identifiant 0Son nom : Etud0donnez un identifiant : 1donnez un nom : Etud1Identifiant 1Son nom : Etud1donnez un identifiant : 2donnez un nom : Etud222Identifiant 2Son nom : Etud222---- Etud3 ---- donnez un identifiant : 33donnez un nom : ETUD33Identifiant 33Son nom : ETUD33Dans l'en-tête, le nom de la fonction Etudiant::Saisie(), signifie que la fonction Saisie()est celle définie dans la structure Etudiant. En l'absence de ce "préfixe" (Etudiant::), nousdéfinirions effectivement une fonction nommée Saisie(), mais celle-ci ne serait plusassociée à Etudiant; il s'agirait d'une fonction "ordinaire" et non plus de la fonctionmembre de la structure Etudiant.RqDans les fonctions Saisie() et Affiche(), il faut remarquer l’utilisation de Id et du Nom qui nesont ni des arguments de fonctions ni des variables locales. En fait, ils désignent lesmembres Id et Nom de la structure Etudiant. L’association est réalisée par Etudiant:: del’en-tête des fonctions.Voici un autre exemple utilisant cette fois ci la structure point.#include iostream using namespace std ;struct point {int x ;int y ;// Déclaration des fonctions membres (méthodes)void initialise(int, int) ;void affiche() ;};void Affiche2(point A, point B){ // fonction non membrecout "\n .Je suis dans Affiche2 ." "\n" ;A.affiche();B.affiche();}// --- Définition des fonctions membres du type point --void point::initialise (int abs, int ord) {x abs ; y ord ;}void point::affiche () {cout "Je suis en " x " " y "\n" ;}M. BENJELLOUNInfo IIS. Informatique
Chap 1 : Les structures et fonctions membres6void main() {point a, b, TabPoint[3];a.initialise (3, 7) ; a.affiche () ;b.x 10; b.y 20 ; b.affiche ();for(int i 0 ; i 3 ; i ){TabPoint[i].initialise(i, i 4);TabPoint[i].affiche();}Affiche2(a, b);}Programme en3 710 200 41 52 6.Je suis dans Affiche2 .Je suis en 3 7Je suis en 10 20R qs Dans le cas des structures, un appel tel que a.initialise (3,7) ; pourrait êtreremplacé par:a.x 3 ; a.y 7 ;Dans un programme, nous pouvons évidemment mélanger fonctions membres etfonctions non membres.ExercicesExercices1.1. Ecrire un programme qui gère un ensemble de Personnes (Nmax 10). Chaque Personne auraune structure avec un identifiant Id de type entier et un nom de type string dont la déclaration est:struct Personne {int Id;string nom;};Ce programme doit gérer en boucle le menu suivant :1 : Saisie et Affichage2 : Ajouter au (début, milieu ou fin) et Affichage3 : Supprimer le début et Affichage4 : Tri selon NOM et Affichage5 : Tri selon Id et Affichage6 : QuitterLe menu sera affiché via une fonction, les choix seront traités via l’instruction case. Votreprogramme utilisera une série de fonctions permettant de séparer les tâches.1.2. Transformez l’exercice précédent en utilisant dans la structure deux fonctions membressaisie() et affichage(). Apporter les modifications nécessaires à la structure, aux fonctions et auprogramme.M. BENJELLOUNInfo IIS. Informatique
Chap 2 : Les listes simplement chaînées2.1. GénéralitésJusqu'à présent, nous n'avons travaillé qu'avec des structures de données statiques, dontl'espace mémoire occupé pouvait être défini avant l'exécution. Dans le cas d’unedéclaration d’un tableau de structure par la syntaxe:struct Etudiant Tab[100] ;Cette déclaration permet de réserver automatiquement une zone mémoire d’une longueurde 100 éléments de type Etudiant. Les cellules du tableau sont alors accessibles par Tab[0]à Tab[99]. Cependant, le problème réside dans le fait que la déclaration du tableau avecune dimension constante fige le nombre d’éléments de ce tableau. Autrement dit, même siun programme n’a besoin que de 20 éléments, on réservera malgré tout 100 cellules de typeEtudiant. Comme nous l’avons déjà vu en 1ère Bachelier, nous pouvons remédier à cela enutilisant les pointeurs. Les instructions deviennent dans ce cas-ci :struct Etudiant *Tab;Pour pouvoir stocker en mémoire une valeur de type Etudiant, il faut donc explicitementdemander une adresse disponible en utilisant le mot réservé new et la libérer avec delete.L’allocation dynamique de la mémoire correspondant au nombre de cellules est maintenantau gré de l’utilisateur. On peut, par exemple, lui demander d’introduire un nombre N, puisnous réservons l’espace mémoire strictement nécessaire.cout " Dimension du Tableau N : " ;cin N;// Allocation mémoire : new[]Tab new Etudiant[N]; // Restituer la mémoire : delete[]delete[] Tab;Supposons qu’à un moment donné dans le programme même, nous n’ayons plus besoin que de(N-5) éléments. La logique, comme nous désirons optimiser la gestion de la mémoire, est delibérer la place de mémoire pour 5 cellules. Mais cela ne peut se faire ni automatiquementni directement. Donc cela reste bien sûr limitatif. En effet, cela ne permet pas d'exploiterles structures tels que les listes chaînées, les piles, les arbres, structures fondamentalespour de nombreux algorithmes.2.2. Listes Simplement chaînéesUne liste chaînée est une séquence d'objets dynamiques dont chacun contient uneindication explicite vers l'élément suivant. Une liste est faite de cellules. Chaque cellulecontient un élément de la liste et l'adresse de l'élément suivant (structure de même type).
Chap 2 : Les listes simplement chaînées8Considérons donc la définition d'une liste simplement chaînée de structures contenant desstrings."Etud1""Etud2""Etud3""Etud4"NULLChaque cellule de la liste chaînée peut être définie comme une structure:struct Etudiant {string Nom;struct Etudiant *next;};// Etudiant suivantChaque cellule comporte donc une zone mémoire pour stocker son contenu (ici string Nom),ainsi qu'une zone mémoire pour stocker un pointeur vers la cellule suivante (c'est-à-direl'adresse de la cellule suivante).Pour pouvoir travailler avec une liste simplement chaînée, il faut connaître l'adresse de sapremière cellule. Nous définirons donc un pointeur:struct Etudiant *debut;Si les tableaux permettent un accès direct aux éléments, les listes chaînées en sontdépourvues. La définition et la nature même de la liste chaînée font apparaître que l’on nepeut parcourir intégralement la liste qu’en partant du premier élément et en visitant leséléments l’un après l’autre. En contrepartie nous gagnons en souplesse lorsqu’il s’agit demodifier la liste. Des opérations telles que : ajout, suppression d’un élément à une positionquelconque dans la liste, la suppression avec libération de mémoire d’un nombre quelconqued’éléments consécutifs, Voici un programme simple mais complet, dans lequel nous traitons un certain nombred’opérations sur la liste. Par exemple : l'insertion d'une nouvelle cellule en début de liste, leparcours de la liste pour l’affichage, l’effacement d'une cellule, la libération de la mémoire.#include iostream #include string using namespace std ;typedef struct Etudiant{string Nom;struct Etudiant *next;}liste;// le lien : pointeur sur la cellule suivante//insérer un nouvel élément en tête de liste et retourner un pointeur sur la liste.liste *insere en tete(string x , liste *lis ) {liste *c;c new liste ; // créer une celluleif (c ! NULL){c Nom x;// assignation de xc next lis;// assignation de suivant: chaîner avec la première cellule de la listelis c;// chaînage: faire pointer la tête de liste vers la nouvelle cellule.}return (lis);}M. BENJELLOUNInfo IIS. Informatique
Chap 2 : Les listes simplement chaînées9void parcours (liste *lis) {liste *p;p lis;cout "Affichage : " endl;while ( p ! NULL) {cout p Nom endl;p p next;}cout endl endl;}void liberation (liste *lis) {liste *p;p lis;while ( p ! NULL) {lis lis next;delete p;p lis;}}void main() {int i, n;string Name;liste *debut;debut NULL;// si p NULL, donc fin de liste// liste videcout "nombre d'elements N: " ;cin n;//----------------------cout "\n Creer une liste avec insertion en tete de liste affichage \n";for(i 1; i n; i ){cout "\n Nom " i " : ";cin Name;debut insere en tete(Name , debut);}parcours(debut);// Affichage//----------------------cout "Inserer une nouvelle cellule apres la cellule debut " endl;liste *p;p new liste;p Nom "Nouveau";p next debut next;debut next p;parcours (debut);//----------------------cout "Supprimer la 1ere cellule " endl;liste *q;q debut;debut debut next;delete q; // mémoire dynamique n'est plus utilisée doit être libérée.parcours (debut);//-----------------------// Libérationcout " Liberation de la memoire ";liberation (debut);}Programme 2.1.M. BENJELLOUNInfo IIS. Informatique
Chap 2 : Les listes simplement chaînées10nombre d'elements N: 3Creer une liste avec insertion en tete de liste affichageNom 1 : premierNom 2 : secondNom 3 : nom3Affichage :nom3secondpremierSOLUTINInserer une nouvelle cellule apres la cellule debutAffichage :nom3NouveausecondpremierSupprimer la 1ere celluleAffichage :NouveausecondpremierLiberation de la memoireExercicesExercices2.1. Transformer l’exercice 1.2. en remplaçant le tableau statique de structuresPersonne par une liste simplement chaînée.M. BENJELLOUNInfo IIS. Informatique
Chap 2 : Les listes simplement chaînées11Parcours Vita2.2.Ecrire un programme permettant de manipuler plusieurs listesdont le nombre est NL Nmax 15. Il s’agit d’un ParcoursVita avec NL activités et un nombre de participantsNP Nmax. Les informations caractérisant chaque participantdans la liste sont les suivantes: Nom : chaîne de caractèresCode : un caractère (A, B, )Créer la (les) structure(s) nécessaire(s) à ce problème.Les fonctions Saisie(.) et Affichage(.) pour chaque élément(participant) sont déclarées dans la structure participant.Puis on transfert (NomC C) de Liste1 vers Liste2. Ce derniersera inséré dans Liste2 après (NomD D).Ce programme doit gérer en boucle le menu suivant :Liste1 : VideListe2 : (NomD D) --- (NomC C) --- (NB B) ----(NA A)1234-Liste1 :(NA A) --- (NB B)Liste2 :(NomD D) --- (NomC C) Tant que liste1 n’est pas vide, on continue.A la fin on aura l’affichage suivant :SaisieL Liste1 et AffichageListe1 TO Liste2 et AffichageParcours et AffichageFin1- Saisie Liste1 et Affichage:Est constitué au moins de deux fonctions :SaisieL ( .) ;Dans cette fonction on demandera et on testerale nombre de participants (NP) à saisir et oneffectuera la saisie des participants dans une liste parinsertion en tête.Par exemple si NP 4 et l’utilisateur introduit au clavier :(NomD D) puis (NomC C) puis (NB B) et enfin (NA A)La liste est :Attention : Ici on affiche l’état des deux listes chaquefois qu’un participant passe de la liste1 à la liste2.Il faut soigner tous les affichages afin de bien suivre etcomprendre les différentes séquences.!3- Parcours et Affichage:Ici on demandera à l’utilisateur le nombre NL et on y feratraverser les NP participants comme le montre la figure générale(début).On affiche toutes les listes chaque fois que toute l’équipe passed’une liste à l’autre. Si par exemple NL 3 on affichera:Liste1 : (NA A) --- (NB B) --- (NomC C) --- (NomD D)Liste2 : VideListe3 : Vide---------Affichage( .) ;(NA A) --- (NB B) --- (NomC C) --- (NomD D)Liste1 : VideListe2 : (NomD D) --- (NomC C) --- (NB B) ----(NA A)Liste3 : Vide---------2- Liste1 Liste2 et Affichage:Liste1 : VideListe2 : VideIci, comme si les participants sautent, un par un, de la poutre1 Liste3 : (NA A) --- (NB B) --- (NomC C) --- (NomD D)(Liste1) à la poutre2 (Liste2). On applique (FIFO), c'est-àdire, on retire d’abord le D de Liste1, on insère D dans Liste2 RQs :et on affiche liste1 et liste2.Utilisez les règles de bonnes pratiques étudiées durant les travauxListe1 :(NA A) --- (NB B) --- (NomC C)pratiques telles que l’indentation syntaxique, la programmationmodulaire, libérer la mémoire d’un élément supprimé Liste2 :(NomD D)!M. BENJELLOUNInfo IIS. Informatique
Chap3 : Les ClassesLe but de ce chapitre est d’introduire les concepts de base des objets. Ainsi, les termes de"programmation (orientée) objets", de classe, d'objet, de méthode, d’encapsulation et typede membre (publique, privé) vont être définis. Ce chapitre n’a pas la prétention d’expliqueren détail ce type de conception, mais se propose d’en introduire les idées maîtresses enpréambule à l’étude du langage C . Afin d’illustrer par la programmation ces concepts, cechapitre est agrémenté de nombreux programmes permettant à l’étudiant d’assimiler lesprincipales notions et de comprendre quelques subtilités de cette matière. Pour plus deprécisions, le lecteur pourra se reporter aux références.Des notions comme l'héritage, le polymorphisme, seront abordées dans d’autreschapitres de ce syllabus.3.1. Classes et objetsUne classe définit un regroupement de données et de fonctions ou méthodes. D'un point devue syntaxique, une classe ressemble beaucoup à la définition d’une structure, il suffit de remplacer le mot clé struct par le mot réservé class; préciser quels sont les membres publics (fonctions ou données) et les membresprivés en utilisant les mots clés public et private.struct Etudiant {int Id;string Nom;void Saisie();void Affiche();};Class Etudiant {private :// Cachées aux fonctions externesint Id;string Nom;public : // Accessibles depuis l'extérieur de la classevoid Saisie();void Affiche();};La déclaration d’une classe commence par le mot-clé class suivi du nom de la classe et setermine par le point-virgule obligatoire. Le nom de la classe dans cet exemple est Etudiant.On appelle objet, une donnée d'un type class, c’est une instanciation d’une classe.Class Etudiant Etud1 ;// Etudiant est une classe, Etud1 est une instance d’un objet. fonction membre ou méthode, un membre d'une classe qui est une fonction (Saisie), donnée membre, un membre qui est une variable (Id et Nom).Le C introduit des concepts de programmation orientée objet. Un des concepts majeursest l'encapsulation des données.
Chap3 : Les Classes133.2. Concept d’encapsulationDans la classe Etudiant, toutes les fonctions membres sont désignées comme public ettoutes les données membres comme private; les premières étant accessibles depuisl’extérieur de la classe, les secondes l’étant seulement depuis la classe.L'association de membres et fonctions au sein d'une classe, avec la possibilité de rendreprivées certains d'entre eux, s'appelle l'encapsulation des données, un des conceptsmajeurs de la programmation orientée objet. Intérêt de la démarche: puisqu'elles ont étédéclarées privées, les données membres Id et Nom ne peuvent être modifiées autrementque par un appel de la fonction Saisie().En effet, l'encapsulation est un mécanisme consistant à rassembler les données et lesméthodes au sein d'une classe en cachant l'implémentation de l'objet: cacherl'information contenue dans un objet et ne proposer que des méthodes ou des fonctions demanipulation de cet objet. Ainsi les propriétés contenues dans l'objet serontassurées/validées par les méthodes de l'objet et ne seront plus de la responsabilité del'utilisateur extérieur. Les fonctions membres doivent pouvoir servir d'interface pourmanipuler les données membres.L'utilisateur extérieur ne pourra pas modifier directement l'information et risquer demettre en péril les propriétés comportementales de l'objet.L'encapsulation permet donc de garantir l'intégrité des données contenues dans l'objet.On place l'étiquette public devant les fonctions membres dédiées à la manipulation desdonnées membres. En effet, si l'utilisateur de la classe ne peut pas modifier les donnéesmembres directement, il e
du langage C ainsi que les notions fondamentales de programmation ont été étudiées durant le cours d'Informatique I et sont supposées acquises. Durant ce cours, les notions fondamentales de la programmation orientée objet sont abordées. Nous commençons par un rappel sur les structures auxquelles nous introduisons les fonctions membres.
D epartement d’informatique et de g enie logiciel, Universit e Laval Qu ebec, Canada, G1V 0A6 Hugo Larochelle hugo.larochelle@usherbrooke.ca D epartement d’informatique, Universit e de Sherbrooke Qu ebec, Canada, J1K 2R1 Fran cois Laviolette Francois.Laviolette@
Introductionàl’informatique Courscomplet G.Santini,J.-C.Dubacq IUTdeVilletaneuse S12016 G.Santini,J.-C.Dubacq (IUTV) Introductionàl’informatique S12016 1/235
Conduite d'un projet informatique Séquence 7 Conduite d'un projet informatique . pour un projet relatif au développement du commerce électronique d’une . (rapid application developpement) UML préco-nise un processus en spirale où une maquette, ou une petite partie du projet final, est .
Gestion de la documentation informatique (base de connaissance, FAQ, etc.) ; . référentiel commun de bonnes pratiques quant à ses processus métier. . L'objectif de ce TP est de simuler, dans le laboratoire réseau, la gestion d'un parc informatique
institut de la francophonie pour l’informatique institut national de recherche en informatique et en automatique memoire de fin d’etudes master d’informatique reparation des trajectoires de personnes suivies basee sur le clustering de points etudiant : chau duc phu u promotion : xii sous la direction de :
Loïc NOEL Rapport de stage de Master M2 INFORMATIQUE 06/06/2016 NOEL_Loic-rapport_stage_M2_Info.pdf Page 5 / 50 1. Introduction Dans le cadre de ma dernière année de Master Informatique à l’Université de La Réunion, je dois effectuer un stage de fin d’étude d’
Cours: Algorithmique et Programmation 2 (UE: Math ematique et Informatique) 31 janvier 2020 Informations G en erales Responsable Charles Paperman Semestre S3 Enseignement Obligatoire { Pr esentiel UEs pr e-requises Modalit es d' evaluation CC CT Structure ECTS El ement de cours Algorithmique et Programmation 2 Unit e d'enseignement Math ematique et Informatique 18 Bloc de comp etence Math .
No de cours : 420-KEL-LG à l'enseignement régulier Plan de cours Intégration de techniques nouvelles en informatique de gestion1 Programme : 420.A0 Pondération : 2-2-2 Préalables : 420-KEJ-LG Cours associés : - Discipline : Informatique Professeur Bureau Téléphone Courriel Patrice Roy F-314, aile Frenette poste 2780 Patrice.Roy@clg.qc.ca 1 et, exceptionnellement, en informatique .
