C est un langage populaire (cours IFT 1810, IFT 1160)
20 pages
Français

C est un langage populaire (cours IFT 1810, IFT 1160)

-

Le téléchargement nécessite un accès à la bibliothèque YouScribe
Tout savoir sur nos offres

Description

Classes et objets Structures en C++ avec fonctions membres : En C++, nous pouvons inclure des membres fonctions à l’intérieur d’une structure (ce qui n’est pas le cas en C). Ces fonctions, ont le rôle de manipuler les membres données de la structure. #include struct Point { int x,y; // membres de données //fonctions membres void initialise(); void afficher(char *); double longueur(); }; // on accède aux fonctions membres par l’intermédiaire de l’opérateur // unaire de résolution de portée :: void Point :: initialise() { x=3; y=4; } void Point::afficher(char * message) { cout << message << " (x = " << x << " et y = " << y << ")\n\n"; } double Point ::longueur() { return sqrt(x*x + y*y); } void main() { Point P; // déclaration de la variable P du type Point P.initialise(); P.afficher("via la fonction afficher()"); cout << "Point P, x= " << P.x << endl; cout << "Point P, y= " << P.y << endl; cout << "Point P, longueur= " << P.longueur() << endl; } /*Execution via la fonction afficher (x=3 et y=4) Point P, x=3 Point P, y=4 Point P, longueur=5 */ Classes : La classe décrit le modèle structurel d'un objet : ensemble des attributs (ou champs ou données membres) décrivant sa structure ensemble des opérations (ou méthodes ou fonctions membres) qui lui sont applicables. struct Point { ...

Sujets

Informations

Publié par
Nombre de lectures 119
Langue Français
Classes et objets
  Structures en C++ avec fonctions membres :  En C++, nous pouvons inclure des membres fonctions à l ’intérieur d’une structure (ce qui n’est pas le cas en C).  Ces fonctions, ont le rôle de manipuler les membres données de la structure.  #include <iostream.h>  struct Point {  int x,y; // membres de données  //fonctions membres  void initialise();  void afficher(char *);  double longueur(); };  // on accède aux fonctions membres par l’intermédiaire de l’opérateur  // unaire de résolution de portée ::  void Point :: initialise() {  x=3;  y=4; }  void Point::afficher(char * message) {  cout << message  << " (x = " << x << " et y " << y << ")\n\n"; = }  double Point ::longueur() {  return sqrt(x*x + y*y); }   void main() {   Point P; // déclaration de la variable P du type Point                     P.initialise();   P.afficher("via la fonction afficher()");   cout << "Point P, x= " << P.x << endl;  cout << "Point P, y= " P.y << endl; <<  cout << "Point P, longueur= " << P.longueur() << endl; }   /*Execution
 via la fonction afficher (x=3 et y=4) Point P, x=3 Point P, y=4 Point P, longueur=5 */  Classes :
La classe décrit le modèle structurel d'un objet :
 ensemble des attributs (ou champs ou données membres ) décrivant sa structure  ensemble des opérations (ou méthodes ou fonctions membres ) qui lui sont applicables.
struct Point { class Point {  int x,y; int x,y;  void initialise(); void initialise();  void afficher(char *); void afficher(char *);  double longueur(); double longueur(); }; };         Par défaut tous les membres d’une structure sont PUBLICS , i.e. accessibles du monde extérieur. Pour les classes, par défaut, tous les membres sont PRIVÉS.  Les mots réservés public et private délimitent les sections visibles par la classe.  class Triangle {  private :       double hauteur,base; //les coordonnées du triangle: champs privés    public : // fonctions membres publics   double perimetre();  double surface();  void afficher(char *); };   Droits d'accès :
L' encapsulation consiste à masquer l'accès à certains attributs et méthodes d'une classe.
Elle est réalisée à l'aide des mots clés :
 private : les membres privés ne sont accessibles que par les fonctions membres de la classe.
 protected : les membres protégés sont comme les membres privés. Mais ils sont aussi accessibles par les fonctions membres des classes dérivées (par héritage).  public : les membres publics sont accessibles par les méthodes de toutes les classes (dérivées ou non). - Les mots réservés private , protected et public peuvent figurer plusieurs fois dans la déclaration de la classe. Le droit d'accès ne change pas tant qu'un nouveau droit n'est pas spécifié.  - Une fonction membre ( public ou private ) a accès aux données private de la classe  - En général, la déclaration d'une classe contient simplement les prototypes des fonctions membres de la classe. Les fonctions membres sont définies dans un module séparé ou plus loin dans le code source .     double Triangle :: surface() {       return (hauteur* base)/2; }      La définition de la méthode peut aussi avoir lieu à -l'intérieur de la déclaration de la classe. - Une fonction membre définie à l'extérieur de la classe peut être aussi qualifiée explicitement de fonction inline . Instanciation d’une classe :  De façon similaire à une structure , le nom de la classe représente un nouveau type de donnée. On peut donc définir des variables de ce nouveau type; on dit alors qu’on crée un objet ou une instance de cette classe. L'instruction :   Triangle t ; permet de déclarer un objet t de la classe Triangle.  Pour appliquer une méthode sur un objet, on utilise :  
         objet.méthode(arguments si nécessaire)  Exemples : t . afficher("t");          cout Perimetre : " << << " t.perimetre() << endl;  Constructeurs:  Un constructeur permet de construire un objet d'une classe. C'est une méthode qui n'est pas de type void, ne retourne aucune valeur et porte le même nom de la classe. Ainsi, les constructeurs d'une même classe ont tous le même nom de la classe. C'est possible grâce à la surcharge des méthodes qui est permise en C++.  a) classe sans constructeur :          La classe Point0 suivante ne dispose pas du tout de constructeur : aucune méthode portant le nom de la classe (ici Point0).   class Point0 {  private :  int x, y ;  public :  void afficher(char *); };  // DÉFINITION de la fonction membre afficher void Point0::afficher(char * message) {  cout << message << endl  << " (x = " << x << " et y = " << y << ")\n\n"; }  Une déclaration du genre :  Point0 p0; provoque l'appel d'un constructeur par défaut de C++ qui affecte des valeurs par défaut à chaque champ de l'objet (initialisation quelconque choisie par le compilateur)  Avec   Point0 p0 ;  p0.afficher("C++ construit p0 avec un constructeur par defaut"); On obtient :  
 
  C++ construit p0 avec un constructeur par defaut  (x = -858993460 et y = -858993460)  Comment donner de valeurs aux champs d'un objet quand  on n'a pas de constructeur ? 1.  utiliser des méthodes set... (mettre telle valeur à tel champ)      class Point {  private :  int x, y ;  public :  void setAbscisse( int abs) {  x abs ; =  }   void setOrdonne( int ord) {  y = ord ;  }   void afficher(String nom) {  cout <<("Coordonnees du point "                          << nom )" << endl << " << " (x = " << x << " et y = "   << y << ")\n";    }  };                Vous comprenez facilement le programme suivant :     void main () {    Point p1 ;  p1.afficher("p1 (valeurs par defaut)");     p1.setAbscisse(12);  p1.afficher("p1 (avec x vaut 12 et y par defaut)");     p1.setOrdonnee(7); p1.afficher("p1 (x vaut 12 et y vaut 7)");   }             /* Exécution : Coordonnees du point p1 (valeurs par defaut) x = -858993460 et y = -858993460 Coordonnees du point p1 (avec x vaut 12 et y par defaut) x = 12 et y = -858993460 Coordonnees du point p1 (x vaut 12 et y vaut 7) x = 12 et y = 7 / *   2.  utiliser de méthode très classique : initialiser  
  class Point {  private :  int x, y ;  public :  void initialiser(int abs, int ord)  {  x = abs ;  y = ord ;            }  etc . . .  } ;   Pour créer un point p de coordonnées 25, 52 :   Point p ;  p.initialiser(25, 22);   Il y a ainsi deux actions : - déclarer et construire avec des valeurs     par défauts - initialiser avec des valeurs voulues   Peut-on simplifier avec une seule action? - Oui! en utilisant un constructeur  approprié.   b) classe avec un seul constructeur approprié :   Observons la classe suivante :    class Point1 {  private :  int x, y ;  public :                  Point1(int , int );  void afficher(char *); };  Point1::Point1(int abs, int ord) {  cout << "Un constructeur avec deux parametres \n";  x = abs ;  y = ord; }    void Point1::afficher(char * message) {  cout << message
 << " (x = " << x << " et y = " << y << ")\n\n"; }  Comment construire un point d’abscisse 12 et       d’ordonné 10 ?        Point1 p1(12, 10);    p1 est un objet de la classe Point1. C++ alloue l'espace mémoire pour mémoriser les informations de p1 (son abscisse et son ordonné).  La classe Point1 dispose donc d’un constructeur avec paramètre(s). Dans ce cas ci, l'instruction:  Point1 p1a ;  provoque une erreur à la compilation. Vous n'avez pas explicitement de constructeur sans paramètre, il faut appeler le constructeur existant avec paramètres. C++ ne fournit plus son constructeur par défaut (sans paramètre).  Comment régler ce problème de syntaxe?   Ajouter un constructeur sans paramètre  c) classe avec plusieurs constructeurs appropriés :    #include <iostream.h>      // avoir un constructeur avec parametre(s) // avoir aussi un constructeur sans parametre  class Point2 {  private :  int x, y ;  public :  Point2() {}  Point2(int , int = 1234 );  void afficher(char *); };  Point2::Point2(int abs, int ord) {  cout << "Un constructeur avec deux parametres dont le  dernier par defaut\n";  x = abs;  y = ord; }  void Point2::afficher(char * message) {  cout << message  << " (x = " << x << " et y = " << y << ")\n\n";  
}  void main() {   Point2 p2a ; p2a.afficher("Coordonnees de p2a ");  p2a = Point2(20); p2a.afficher("Coordonnees de p2a avec p2a = Point2(20); ");  Point2 p2b(50, 45); P2b.afficher("Coordonnees de p2b avec Point2 p2b(50, 45) ; ");  Point2 p2c = Point2(555, 444); P2c.afficher("Coordonnees de p2c avec p2c = Point2(555, 444); ");  }  /* Exécution :  Coordonnees de p2a (x = -858993460 et y = -858993460)  Un constructeur avec deux parametres dont le dernier par defaut Coordonnees de p2a avec p2a = Point2(20); (x = 20 et y = 1234)  Un constructeur avec deux parametres dont le dernier par defaut Coordonnees de p2b avec Point2 p2b(50, 45) ; (x = 50 et y = 45)  Un constructeur avec deux parametres dont le dernier par defaut Coordonnees de p2c avec p2c = Point2(555, 444); (x = 555 et y = 444)  */  Supposons maintenant que l'en-tête du constructeur avec paramètres de la classe Point2 est le suivant:    Point2(int x , int y) {  Dans un tel cas, dans le corps du constructeur, il est logique d'écrire :   x = x;  y = y ; où à gauche, on espère qu'ils sont des champs de l'objet et à droite des affectations, les paramètres du constructeur. Ça passe bien à la compilation. Malheureusement, C++ n'est pas capable de distinguer ces identificateurs.  Il faut alors utiliser l'auto référence this qui représente l'objet courant :  
Point2 :: Point2(int x , int y) {   this->x = x ;  this->y = y ; }  On interprète : this->x  comme l’abscisse du point courant .  Voir l’exemple this.cpp disponible sur la page web    Destructeur:  Définition :  méthode spécifique de la classe appelée  implicitement  à la destruction de l’objet.   Caractéristiques :   porte le même nom que la classe précédé de ~ (tilde)   ne retourne pas de valeur, même pas void  n’accepte aucun paramètre, donc ne peut pas être surdéfinie.   Exemple :  #include <iostream.h>  class Point {  private :  int x, y ;  public :  Point() {}  Point(int , int = 1234 );   // destructeur                 Point()  { ~                   cout << "On detruit le point de coordonnes "  << x << " et " << y << endl;                 }  void afficher(char *); };  Point::Point(int abs, int ord) {  cout << "Un constructeur avec deux parametres dont le dernie r  par defaut\n";    x = abs;  y = ord;  }
 void Point::afficher(char * nom) {  cout << "Coordonnes du point << nom << " : " "  << " (x = " << x << " et y y << ")\n\n"; = " << }   Point glob(99, 66);   void test1Destructeur() {  Point a(20,15), b(75);  cout << "On est dans la fonction test1Destructeur() : \n";   a.afficher("a");  b.afficher("b");  glob.afficher("glob");  cout << "On est a la fin de la fonction test1Destructeur() \n\n";  }  void main() {   test1Destructeur();   Point z(100, 200);  z.afficher("z");   { // bloc1 :  Point c (15, 50);  cout << "\nOn est dans le bloc 1 :\n";  c.afficher("c");  { // bloc 2  Point d (567, 98);  cout << "\nOn est dans le bloc 2 :\n";  d.afficher("d");  glob.afficher("glob dans bloc 2");  cout << "On quitte le bloc 2 :\n";  }  cout << "\nOn quitte le bloc 1 :\n";  }  cout << "On est en dehors du bloc 1 :\n";  cout << "\nOn quitte main\n"; }  /* Exécution : Un constructeur avec deux parametres dont le der nier par defaut Un constructeur avec deux parametres dont le dernier par defaut Un constructeur avec deux parametres dont le dernier par defaut On est dans la fonction test1Destructeur() : Coordonnes du point a : (x = 20 et y = 15)  Coordonnes du point b : (x = 75 et y = 1234)  Coordonnes du point glob : (x = 99 et y = 66)  On est a la fin de la fonction test1Destructeur()  On detruit le point de coordonnes 75 et 1234
On detruit le point de coordonnes 20 et 15 Un constructeur avec deux parametres dont le dernier par defaut Coordonnes du point z : (x = 100 et y = 200)  Un constructeur avec deux parametres dont le dernier par defaut  On est dans le bloc 1 : Coordonnes du point c : (x = 15 et y = 50)  Un constructeur avec deux parametres dont le dernier pa r defaut  On est dans le bloc 2 : Coordonnes du point d : (x = 567 et y = 98)  Coordonnes du point glob dans bloc 2 : (x = 99 et y = 66)  On quitte le bloc 2 : On detruit le point de coordonnes 567 et 98  On quitte le bloc 1 : On detruit le point de coordonnes 15 et 50 On est en dehors du bloc 1 :  On quitte main On detruit le point de coordonnes 100 et 200 On detruit le point de coordonnes 99 et 66  */  Membres statiques :  Une classe est une moule à objets ; chaque objet a sa propre copie de champs.  Un champ statique est un champ de la classe et non des objets. Ce champ est partagé par tous les objets de la classe ; il existe un seul exemplaire pour toute la classe.  #include < iostream.h>  class Point {  private :  int x, y ;  public :          static int nbPoints;  Point();  ~Point(); };  int Point:: nbPoints =0; //initialisation obligatoire sous cette forme   Point :: Point() {  nbPoints++; }