BifaceMcLeOD The HighGlandeur | Au lieu d'écrire:
Code :
- int min(int a, int b) {
- if (a < b) {
- return a;
- }
- else {
- return b;
- }
- }
- short min(short a, short b) {
- if (a < b) {
- return a;
- }
- else {
- return b;
- }
- }
- float min(float a, float b) {
- if (a < b) {
- return a;
- }
- else {
- return b;
- }
- }
- double min(double a, double b) {
- if (a < b) {
- return a;
- }
- else {
- return b;
- }
- }
- String min(String a, String b) {
- if (a < b) {
- return a;
- }
- else {
- return b;
- }
- }
|
Tu peux écrire :
Code :
- template <class T>
- T min(T a, T b) {
- if (a < b) {
- return a;
- }
- else {
- return b;
- }
- }
|
Avantage : tu évites de dupliquer ton code n fois (puisque le code n'existe qu'en un seul exemplaire : le code générique), et tu as une fonction qui est potentiellement définie pour tout type T sur lequel (ici), il existe un opérateur "<" (elle ne l'est réellement que quand tu l'"instancie" pour un type donné, c'est-à-dire quand tu l'utilise pour un type donné).
Si tu corriges un bug dans une des fonctions "dupliquées", il est souvent difficile d'être sûr que tu as bien corrigé le même bug dans tous les endroits où cette fonction est dupliquée. Avec un template, il n'y a qu'un seul endroit à corriger, puisque le code est unique.
Inconvénient des templates en C++ : Les présupposés sur le type générique ne sont pas explicités, ce qui est parfois gênant (les implicites sont souvent source de bugs). D'autres langages (comme Ada, par exemple) t'obligent à déclarer les présupposés sur ton type générique, ce qui est plus clair. Par ailleurs, C++ utilise aussi l'instanciation implicite des templates : utilisation d'un template instancié vaut déclaration, ce qui est dangereux. D'autres langages (oui, je sais, encore Ada, par exemple) obligent le programmeur à déclarer chaque instanciation ("je vais utiliser tel module ou telle fonction générique, appliqué à tel type" ) avant de pouvoir l'utiliser. Ce que je trouve plus sûr. [edtdd]--Message édité par BifaceMcLeOD--[/edtdd] |