La programmation orientée objet

Classes et instances

L’objectif poursuivi par Bjarne Stroustrup était, rappelons-le, d’implémenter sur un compilateur C les classes décrites par le langage Simula. Ces deux derniers langages étant radicalement opposés dans leur approche, il fallait identifier une double continuité, notamment du côté du C.

Il fut aisé de remarquer que la programmation serait grandement simplifiée si certaines fonctions pouvaient migrer à l’intérieur des structures du C. De ce fait, il n’y aurait plus de structure à passer à ces fonctions puisqu’elles s’appliqueraient évidemment aux champs de la structure.

Toutefois, il fallait conserver un moyen de distinguer deux instances et c’est pour cette raison que l’on a modifié la syntaxe de l’opérateur point :

struct Point  
{  
int x,y; 
}; 
void afficher(Point p) 
{   
 printf("%d,%d\n",p.x,p.y);  
} 

struct Point  
{ 
int x,y;   
 void afficher()  
{   
printf("%d,%d\n",x,y);  
}  
}; 

Point p1;  
afficher(p1); 

Point p1;  
p1.afficher(); 

Cette différence d’approche a plusieurs conséquences positives pour la programmation. Pour commencer, le programmeur n’a plus à effectuer un choix parmi les différents modes de passage de la structure à la fonction afficher(). Ensuite, nous allons pouvoir opérer une distinction entre les éléments (champs, fonctions) de premier plan et de second plan. Ceux de premier plan seront visibles, accessibles à l’extérieur de la structure. Les autres seront cachés, inaccessibles.

Ce procédé garantit une grande indépendance dans l’implémentation d’un concept, ce qui induit également une bonne stabilité des développements.

Héritage

class Compte  
{  
protected:  
  int numero;    // numéro du compte  
  double solde;    // solde du compte  
  
  static int num;  // variable utilisée pour calculer le prochain 
numéro 
  static int prochain_numero();  
  
public:  
  char*titulaire;    // titulaire du compte  
  
  Compte(char*titulaire);  
  ~Compte(void);  
  void crediter(double montant);  
  bool debiter(double montant);  
  void relever();  
}; 

Autres aspects de la POO

#include <string.h>  
  
class Chaine  
{  
private:  
  char*buffer;  
  int t_buf;  
  int longueur;  
public:  
  // un constructeur par défaut  
  Chaine()  
  {  
    t_buf=100;  
    buffer=new char[t_buf];  
    longueur=0;  
  }  
  Chaine (int t_buf)  
  {  
    this->t_buf=t_buf;  
    buffer=new char[t_buf];  
    longueur=0;  
  }  
  
Chaine(char c)  
  {  
    t_buf=1;  
    longueur=1;  
    buffer=new char[t_buf];  
    buffer[0]=c;  
  }  
  
  Chaine(char*s)  
  {  
    t_buf=strlen(s)+1;  
    buffer=new char[t_buf];  
    longueur=strlen(s);  
    strcpy(buffer,s);  
  }      
  
  void afficher()  
  {  
    for(int i=0; i<longueur; i++)  
      printf("%c",buffer[i]);  
    printf("\n");  
  }  
} ;  
  
int main(int argc, char* argv[])  
{  
  // Ecriture 1  
  // Conversion par emploi explicite de constructeur  
  Chaine x;  
  x=Chaine("bonjour");  // conversion  ...

Les exceptions plus sûres que les erreurs

L’énorme avantage des exceptions vient du fait qu’elles sont intrinsèques au langage, et même à l’environnement d’exécution (runtime voire framework). Elles sont donc beaucoup plus sûres pour contrôler l’exécution d’un programme multithread (ce qui est le cas de nombreuses librairies). De plus, les exceptions guident le programmeur et lui facilitent la tâche de structuration du code. En d’autres termes, il est difficile de s’en passer lorsque l’on maîtrise leur utilisation.

Le langage C++ propose des exceptions structurées, bien entendu à base de classes et d’une gestion avancée de la pile. L’idée est de mettre une séquence d’instructions - pouvant contenir des appels à des fonctions - sous surveillance. Lorsqu’un problème survient, le programmeur peut intercepter l’exception décrivant le problème au fil de sa propagation dans la pile.

Le principe des exceptions C++ est de séparer la détection d’un problème de son traitement. En effet, une fonction de calcul n’a sans doute pas les moyens de décider de la stratégie à adopter en cas de défaillance. Les différentes alternatives sont de continuer avec un résultat faux, d’intégrer de nouvelles valeurs saisies par l’utilisateur, de suspendre le calcul...

Lorsqu’une fonction déclenche une exception, celle-ci est propagée à travers la pile des appels jusqu’à ce qu’elle soit interceptée.

Cette organisation réduit à néant les contraintes imposées par la bibliothèque du langage C ; il n’y a plus d’accès concurrentiel à une variable globale chargée de décrire l’état d’erreur, puisque le contexte de l’erreur est défini par une instance à part entière. Le déclenchement d’une exception provoque un retour immédiat de la procédure ou de la fonction et débute la recherche d’un bloc de traitement....

Programmation générique

Le langage C est trop proche de la machine pour laisser entrevoir une réelle généricité. Au mieux, l’emploi de pointeurs void* (par ailleurs introduits par C++) permet le travail sur différents types. Mais cette imprécision se paye cher, tant du point de vue de la lisibilité des programmes que de la robustesse ou des performances.

Les macros ne sont pas non plus une solution viable pour l’implémentation d’un algorithme indépendamment du typage. Les macros développent une philosophie inverse aux techniques de la compilation. Elles peuvent convenir dans certains cas simples mais leur utilisation relève le plus souvent du bricolage.

Reste que tous les algorithmes ne sont pas destinés à être implémentés pour l’universalité des types de données C++. Pour un certain nombre de types, on se met alors à penser en termes de fonctions polymorphes.

Finalement, les modèles C++ constituent une solution bien plus élégante, très simple et en même temps très sûre d’emploi. Le type de donnée est choisi par le programmeur qui va instancier son modèle à la demande. Le langage C++ propose des modèles de fonctions et des modèles de classes et nous allons traiter tour à tour ces deux aspects.

Travaux pratiques

/*  
        Environnement d'exécution générique  
*/  
class ScriptBox  
{  
public:  
        LexScan*lexScan;  
        Evaluator*parser;  
  
        ScriptBox();  
        ~ScriptBox();  
  
        virtual void init_events();  
  
        void new_text();  
        void set_text(string text);  
        void parse();  
        bool has_errors();  
        string get_errors();  
        string get_text();  
  
        bool set_debug();  
}; 

/*  
        Environnement d'exécution neutre  
*/  
class Sandbox :  
        public ScriptBox  
{  
public:  
        Sandbox();  
        ~Sandbox();  
}; 

/*  
        Environnement...