1. Introduction au C++



sommaire chapitre 1

1.4. Différence entre procédural et objet

Dans son ouvrage Algorithmes et Structures de Données, Niklaus Wirth stipule qu'on peut résumer l'activité de programmation par la formule suivante :

programme = algorithmes + structures de données

en fait, on devrait écrire :

(Procédural/Impératif)     programme = algorithmes( structures de données, paramètres )

dès lors on peut reprendre la formule et l'adapter à la programmation objet :

(Objet)     programme = structures de données.algorithmes( paramètres )

Les principaux avantages de la programmation objet sont les suivants :

  • encapsulation des données : visibilité, protection (public, protected, private)
  • héritage : réutilisation du code
  • polymorphisme : synthèse (plusieurs fonctions différentes avec le même nom)

Si on ajoute à cela la généricité, on autorise l'abstraction et la conception de programme est alors plus proche des concepts humains.

Exemples

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. // data structure
  6. typedef struct _Person {
  7.     char name[25];
  8.     int age;
  9. } Person;
  10.  
  11. /**
  12.  * create new structure of type Person
  13.  */
  14. Person *Person_create() {
  15.     Person *p = (Person *) malloc(sizeof(Person));
  16.     return p;
  17. }
  18.  
  19. /**
  20.  * remove existing Person
  21.  */
  22. void Person_destroy(Person *p) {
  23.     free(p);
  24. }
  25.  
  26. /**
  27.  * initialize data structure
  28.  * @param p pointer to Person
  29.  * @param n name of the Person
  30.  * @param a age of the Person
  31.  */
  32. void Person_init(Person *p, char *n, int a) {
  33.     strcpy(p->name, n);
  34.     p->age = a;
  35. }
  36.  
  37. /**
  38.  * set name of given Person
  39.  * @param p pointer to Person
  40.  * @param n name of the Person
  41.  */
  42. void Person_set_name(Person *p, char *n) {
  43.     strcpy(p->name, n);
  44. }
  45.  
  46. /**
  47.  * display name of the Person
  48.  * @param p pointer to Person
  49.  */
  50. void Person_print(Person *p) {
  51.     printf("%s %d", p->name, p->age);
  52. }
  53.  
  54. // main
  55. int main() {
  56.     Person *p = Person_create();
  57.     Person_init(p, "toto", 10);
  58.     Person_print(p);
  59.     Person_destroy(p);
  60.     return 0;
  61. }
  62.  
  1. #include <iostream>
  2. #include <cstring>
  3. using namespace std;
  4.  
  5. class Person {
  6. protected:
  7.     char name[25];
  8.     int age;
  9.    
  10. public:
  11.     /**
  12.      * constructor
  13.      *
  14.      */
  15.     Person(char *n, int a) {
  16.         strcpy(name, n);
  17.         age = a;
  18.     }
  19.  
  20.     /**
  21.      * set name of given Person
  22.      * @param p pointer to Person
  23.      * @param n name of the Person
  24.      */
  25.     void set_name(char *n) {
  26.         strcpy(name, n);
  27.     }
  28.  
  29.     /**
  30.      * display name of the Person
  31.      * @param p pointer to Person
  32.      */
  33.     void print() {
  34.         cout << name << " " << age;
  35.     }
  36. };
  37.  
  38. // main
  39. int main() {
  40.     Person *p = new Person("toto", 10);
  41.     p->print();
  42.     delete p;
  43.     return 0;
  44. }
  45.