Programmation C++/Polymorphisme
Polymorphisme.
Le polymorphisme est une fonctionnalité de l'héritage : la capacité d'appeler une méthode en fonction du type réel d'un objet (sa classe).
Exemple.
Soit une classe A implémentée de la manière suivante :
 class A
 public:
 int compare(A autre); // compare deux objets A
 static void sort(A** tableau_de_a,int nombre); // tri
La méthode statique codice_1 effectue le tri du tableau en appelant la méthode codice_2.
Soit une classe B héritant de A, ayant un critère supplémentaire de comparaison. Il faut donc une nouvelle version de la méthode de comparaison :
 class B : public A
 public:
 int compare(A autre); // compare deux objets A
Problème.
Si on a un tableau de pointeur sur des objets B, la méthode codice_2 appelée par la fonction de tri est celle de la classe A, car la fonction a pour paramètre un tableau de pointeur sur des objets A. Ce comportement n'est pas polymorphique.
Solution.
Pour que la méthode appelée soit celle de la classe B, il faut qu'elle soit déclarée virtuelle (codice_4) dans la classe de base :
 class A
 public:
 virtual int compare(A autre); // compare deux objets A
 static void sort(A** tableau_de_a,int nombre); // tri
La fonction de tri appellera alors la méthode selon le type réel des objets, même en utilisant un pointeur sur des objets A.
En fait, le compilateur construit une table des fonctions virtuelles pour les classes A et B et les autres sous-classes, et chaque objet créé possède un pointeur vers cette table.

Programmation C++/Les exceptions
Exceptions en C++.
Une exception est l'interruption de l'exécution du programme à la suite d'un événement particulier. Le but des exceptions est de réaliser des traitements spécifiques aux événements qui en sont la cause. Ces traitements peuvent rétablir le programme dans son mode de fonctionnement normal, auquel cas son exécution reprend. Il se peut aussi que le programme se termine, si aucun traitement n'est approprié. 
Le C++ supporte les exceptions logicielles, dont le but est de gérer les erreurs qui surviennent lors de l'exécution des programmes. Lorsqu'une telle erreur survient, le programme doit lancer une exception. L'exécution normale du programme s'arrête dès que l'exception est lancée, et le contrôle est passé à un gestionnaire d'exception. Lorsqu'un gestionnaire d'exception s'exécute, on dit qu'il a attrapé l'exception. 
Les exceptions permettent une gestion simplifiée des erreurs, parce qu'elles en reportent le traitement. Le code peut alors être écrit sans se soucier des cas particuliers, ce qui le simplifie grandement. Les cas particuliers sont traités dans les gestionnaires d'exception. 
En général, une fonction qui détecte une erreur d'exécution ne peut pas se terminer normalement. Comme son traitement n'a pas pu se dérouler normalement, il est probable que la fonction qui l'a appelée considère elle aussi qu'une erreur a eu lieu et termine son exécution. L'erreur remonte ainsi la liste des appelants de la fonction qui a généré l'erreur. Ce processus continue, de fonction en fonction, jusqu'à ce que l'erreur soit complètement gérée ou jusqu'à ce que le programme se termine (ce cas survient lorsque la fonction principale ne peut pas gérer l'erreur). 
Lancer une exception.
Lancer une exception consiste à retourner une erreur sous la forme d'une valeur (message, code, objet exception) dont le type peut être quelconque (codice_1, codice_2, codice_3, ...).
Le lancement se fait par l'instruction codice_4 :
 throw 0;
Attraper une exception.
Pour attraper une exception, il faut qu'un bloc encadre l'instruction directement, ou indirectement, dans la fonction même ou dans la fonction appelante, ou à un niveau supérieur. Dans le cas contraire, le système récupère l'exception et met fin au programme.
Les instructions codice_5 et codice_6 sont utilisées pour attraper les exceptions.
 try {
 ... // code lançant une exception (appel de fonction, ...)
 catch (int code)
 cerr « "Exception " « code « endl;
Exemple de fonction lançant une exception :
int division(int a, int b)
 if (b == 0)
 throw 0; // division par zéro;
 else return a / b;
void main()
 try {
 cout « "1/0 = " « division(1, 0) « endl;
 catch (int code)
 cerr « "Exception " « code « endl;
Attraper toutes les exceptions.
Spécifier les points de suspension dans la clause codice_6 permet d'attraper tous les autres types d'exception :
void main()
 try {
 cout « "1/0 = " « division(1, 0) « endl;
 catch (int code)
 cerr « "Exception " <codice_8 de l'exemple précédent, peut être suivie d'une liste de ces types d'exceptions dans une clause codice_4 :
int division(int a, int b) throw(int)
 if (b == 0) throw 0; // division par zéro;
 else return a / b;
Par défaut, la fonction peut lancer n'importe quel type d'exception. La déclaration de la fonction codice_10 sans clause codice_4 est donc équivalent à la déclaration suivante :
int division(int a, int b) throw(...) // n'importe quel type d'exception
 if (b == 0)
 throw 0; // division par zéro;
 else
 return a / b;
Si une fonction ne lance aucune exception, on peut la déclarer avec une clause codice_4 vide :
int addition(int a, int b) throw() // aucune exception
 return a+b;
Cette clause peut être présente dans les cas suivants :
En revanche, il n'est pas possible de l'utiliser avec codice_13.
Une déclaration avec clause codice_4 limite donc les types d'exception que la fonction peut lancer.
Toute tentative de lancer un autre type d'exception est détectée à l'exécution et provoque l'appel de la fonction codice_15, puis l'arrêt immédiat du programme. Ce comportement est spécifique au C++, et amène souvent les développeurs à remplacer cette clause par une simple documentation.
De plus, l'utilisation de la clause codice_4 reste rare car rendant les pointeurs de fonctions incompatibles s'ils ne possèdent pas une clause couvrant les types lancés par la fonction pointée.
Il est possible de fournir sa propre fonction codice_15 appelée en cas d'exception non attrapée, grâce à codice_18.
void maTerminate()
 std::cout « "Dans ce cas, c\'est grave !" « std::endl;
int main()
 std::set_terminate(maTerminate); // On fournit sa propre fonction
 std::terminate(); // Et on termine le programme.
 return 0;