Template ✱
**********

.. include:: ../BoutonGoogleTrad.rst

Modèle de fonction
==================

Introduction
------------

Prenons une fonction *max()* qui traite des entiers :

.. code-block::

	int    max(int    a, int    b) { if (b>a) return b; else return a; }

Supposons que l'on appelle cette *fonction max()* avec pour arguments deux valeurs flottantes. Que se passe-il ? Pour initialiser les paramètres, on convertit ces valeurs en entier. Mais surtout, après son traitement, la fonction va retourner un entier ce qui peut poser problème. En effet, lorsqu'on appelle *max(3.2,4.5)*, on ne s'attend pas à récupérer comme résultat 4. Pour corriger ce problème, une solution consiste à utiliser le polymorphisme ad hoc en écravant une fonction pour chaque type concerné :

.. code-block::

	int    max(int    a, int    b) { if (b>a) return b; else return a; }
	float  max(float  a, float  b) { if (b>a) return b; else return a; }
	double max(double a, double b) { if (b>a) return b; else return a; }

Cependant, ce choix d’implémentation oblige à répéter plusieurs fois maladroitement la fonction de départ, ceci pour chaque type à traiter.
C’est ainsi qu’est apparu un nouveau concept : la **généricité**, c’est-à-dire la capacité d’une fonction à paramétrer ses types.
Un tel code s’appelle un modèle ou un patron (**template**). L’idée est simple : de la même manière qu’on peut transmettre des valeurs comme arguments d’une fonction, pourquoi ne pas transmettre aussi des types en arguments ?
Voici un exemple de définition d’un template de la fonction *max()* ainsi que son appel : :

.. code-block::

	#include <iostream>

	template<typename T>  T max(T a, T b) { if (b>a) return b; else return a; }

	int main()
	{
		std::cout << max(1,2) << std::endl;
		std::cout << max(1.3,4.5) << std::endl;
	}
	
Entier ou objet ?
-----------------

En choisissant d'écrire une fonction en utilisant un template, vous allez finir
à un moment par vous mélanger. En effet, pour un argument en lecture seule, 
vous avez l'habitude de passer les types fondamentaux (int, double...) par valeur
et les objets  par const référence, ce qui est la bonne attitude. 
Cependant, dans le cas d'un template, on ne sait pas ce que représente le type *T* :
un entier ou un objet bigInteger. Par conséquent, on prend la convention suivante 
qui a le mérite de fonctionner dans les deux configurations :

.. panels::

	:column: col-lg-10 p-2
	
	**CONVENTION** : Dans une fonction template, les paramètres en lecture seule sont passés en utilisant des **const reference**.

En ce qui concerne les arguments devant être modifiés, la question ne se pose pas : que ce soit pour les types 
fondamentaux ou les objets, le passage se fait dans tous les cas par référence, donc aucune ambigüité cette fois.

 
En résumé, voici la syntaxe optimale de la fonction template *max()* pouvaint ainsi aussi bien traiter des *int* que des *bigInteger* :

 
.. code-block::
	
	template<typename T>  T max(const T & a, const T & b)  
	{
		T result;
		... 
		return result; 
	}

Règles de déduction
===================

Soit vous transmettez lors de l'appel de la fonction template tous les paramètres,
soit vous demandez au compilateur de les déduire de manière implicite.
Dans le cas des template, il n'y pas de place à l'ambigüité, 

.. panels::

	:column: col-lg-10 p-2
	
	**CONVENTION** : Dans une fonction template, la déduction du type d'un paramètre T doit être univoque et identique pour tous les arguments.


Exemple 1 : appel implicite
---------------------------

Si nous utilisons le code suivant, nous obtenons une erreur :


.. code-block::

	#include <iostream>

	template<typename T>  T mean(const T & a, const T & b, const T & c)  { return (a+b+c)/3; }

	int main()
	{
		std::cout << mean(1,2,3.14) << std::endl;
	}
	>> no matching function for call to ‘mean(int, int, double)’
	
Le compilateur n'a pas trouvé de fonction/fonction template acceptant un (int,int,double).
Si la fonction *mean()* aurait pu été retenue si on avait passé comme arguments (int,int,int) ou (double,double,double).
Il n'y a pas à ce niveau de mécanisme de conversion implicite.

Cependant, si l'on transmet explicitement les types au template, alors les 
mécanismes de conversion implicite sont actifs :

Ainsi, il faut indiquer explicitement le type utilisé par la fonction template :


.. code-block::

	template<typename T>  T mean(const T & a, const T & b, const T & c)  { return (a+b+c)/3; }

	int main()
	{
		std::cout << mean<int>(1,2,3.14) << std::endl;
	}
	
	>> 2
	
Exemple 2 : le tout générique
-----------------------------

Techniquement, il est possible d'utiliser plusieurs typename dans un template.
Ainsi, on peut pousser le concept encore plus loin en paramétrant tous les types utilisés,
il est même possible de paramétrer le type de retour séparement !

.. code-block::

	#include <iostream>

	template<typename ReturnType,typename T1, typename T2, typename T3>  
	ReturnType mean(const T1 & a, const T2 & b, const T3 & c)  { return (ReturnType)((a+b+c)/3); }

	int main()
	{
		std::cout << mean<float,double,float,int>(9.7,4.8,5) << std::endl;
	}
	>> 6.5
	

Si plusieurs paramètres templates existent, la norme du langage permet de n'en instancier qu'une partie. Ainsi, dans le contexte de l'exemple précédent, on peut écrire : *mean<float,double>(...)*, les deux paramètres suivant étant alors géré comme des paramètres implicites. 


 

Quizzz
======



Indiquez si les syntaxes proposées sont valides (V) ou fausses (F) :


.. quiz:: Template
	:title: Fonction template
		
	*	:quiz:`{"type":"TF","answer":"T"}` template<typename T>  T max(T a, T b) {...}
	*	:quiz:`{"type":"TF","answer":"F"}` template<typename U>  T max(U a, U b) {...}
	*	:quiz:`{"type":"TF","answer":"T"}` template<typename A,typename B>  A max(A a, B b) {...}
	*	:quiz:`{"type":"TF","answer":"F"}` template<typename A,typename B>  A max(T a, T b) {...}
	*	:quiz:`{"type":"TF","answer":"T"}` template<typename A,typename B,typename C>  A max(B a, C b) {...}

	et avec la fonction :	

	.. code-block::

		template<int B,typename A>  int mx(A a) { if (a>B) return a; else return 0;}

 
	*	:quiz:`{"type":"TF","answer":"F"}` mx<int,int>(7);
	*	:quiz:`{"type":"TF","answer":"T"}` mx<4,int>(9.3);
	*	:quiz:`{"type":"TF","answer":"F"}` mx<int,5>(7);
	*	:quiz:`{"type":"TF","answer":"F"}` mx<5>(7,9);
	*	:quiz:`{"type":"TF","answer":"T"}` mx<5>(3.14);
	
	 


Template class
==============

Syntaxe
-------

Les template class fournissent un mécanisme élégant pour créer des classes génériques opérant sur divers types de données. Leur syntaxe est similaire au modèle de fonction. Voici un exemple :

.. code-block::

	template<typename T> 
	struct tuple
	{
		T a;
		T b;
	};

	int main()
	{
		tuple<int> t;
		t.a = 5;
		t.b = 1;
	}


Notes diverses
==============


Assistance de Visual Studio
--------------------------- 
	
En faisant un détour par Visual Studio, si vous placez le curseur de la souris sur l'appel d'une fonction générique,
l'interface vous indique la version choisie par le compilateur :

.. image:: visual.png
	:align: center
	:scale: 40%	
	
 
 
	
Opérateur de conversion de type
-------------------------------

Maintenant que nous connaissons la syntaxe des fonctions templates, nous pouvons introduire l'opérateur 
de convertion de type : **static_cast<type>**. En donnant le type attentdu, 
on peut convertir tout élément vers le type désiré si l'opération est licite :

.. code-block::


	int main()
	{
		double pi = 3.1415;
		std::cout << static_cast<int>(pi) << std::endl;
	}
	>> 3

	 
	
Fonction template avec littéral
-------------------------------

Les paramètres des fonctions templates ne se limitent pas aux types, on peut aussi fournir des littéraux !
Cela peut apporter un gain de performance notable car on injecte des constantes dans le code durant la phase de compilation. Voici un exemple :


.. code-block:: cpp

	template <typename T, int N> 
	T multiply(T value) 
	{
		return value * N;
	}

	int main() 
	{
		std::cout << multiply<int, 5>(10) << std::endl;       // Multiplies 10 by 5
		std::cout << multiply<double, 3>(2.5) << std::endl;   // Multiplies 2.5 by 3
		return 0;
	}



Classe template avec littéral
-----------------------------



Les templates de classe peuvent aussi utiliser des literraux.
Dans l'exemple ci dessous, plûtot que créer un vecteur de taille quelconque,
on force dès la compilation la taille de ce container, ce qui garantit une exécution optimale :

.. code-block::

	#include <iostream>

	template<typename T, int size> struct vfixed
	{
		T v[size];
		void Reset(T r) { for (int i = 0; i < size; i++)  v[i] = r + i; }
	};

	void main()
	{
		vfixed<int, 20> v20;
		v20.Reset(10);

		std::cout << v20.v[0] << " " << v20.v[19] << std::endl;
	}
	
	>> 10 29
	

Nommer des templates spécialisés
--------------------------------

Si vous trouvez la syntaxe à base de <> trop longue, rien ne vous empêche d'instancier un template 
et de lui associer un nom :


.. code-block::

	#include <iostream>

	template<typename T, int size> struct vfixed
	{
		T v[size];
		void Reset(T r) { for (int i = 0; i < size; i++)  v[i] = r + i; }
	};

	using v20i = vfixed<int, 20>;

	void main()
	{
		v20i v20;
		v20.Reset(10);

		std::cout << v20.v[0] << " " << v20.v[19] << std::endl;
	}
	>> 10 29
	

Quizzz
======

.. quiz:: Template
	:title: Questions
		
	*	:quiz:`{"type":"TF","answer":"F"}` Les arguments des templates peuvent être des variables.
	*	:quiz:`{"type":"TF","answer":"T"}` Je peux utiliser le paramètre template d'une classe comme argument d'une fonction template.
	*	:quiz:`{"type":"TF","answer":"T"}` La place d'un template est dans un fichier header.
	*	:quiz:`{"type":"TF","answer":"F"}` Comme argument d'un template, on ne peut trouver que des types.
	*	:quiz:`{"type":"TF","answer":"T"}` On peut donner un nom à une classe template **spécialisée** (template avec template arguments)
	*	:quiz:`{"type":"TF","answer":"T"}` Les arguments des templates doivent être connus à la compilation.

 


	 
Travail à rendre sur Github Classroom
=====================================

Exercice 1 : template function
------------------------------

	* Créez un fichier nommé *5_template_fnt.cpp*

	* Dans le code exemple ci-dessous, transformez les 4 fonctions données vers leurs versions templates.
	
	* Après cela, écrivez une version template de la fonction *test()* pour qu'elle teste les 4 fonctions dans le type donné en argument.
	
	* Changez le *main()* pour que les tests soient effectués en entier, en double et en flottant. Les valeurs numériques restent les mêmes dans la fonction *test()*.
	
	
	* Uploadez le fichier  sur votre github



.. code-block::

	#include <iostream>
	using namespace std;

	int  max(int a, int b)                     { if (a<b) return a; else return b; }
	void swap_int(int& a, int& b)              { int tmp = a; a = b; b = tmp; }
	void leftRotate(int& a, int& b, int& c)    { int tmp = a; a = b; b = c;  c = tmp; }
	int& inc(int& a)                           {  ++a;  return a; }


	void test()
	{
		cout << "max(3, 7)   = " << max(3, 7) << '\n';
		cout << "max(-5, -2) = " << max(-5, -2) << '\n';

		int x = 10, y = 20;
		swap_int(x, y);
		cout << "swap: x=" << x << ", y=" << y << '\n';

		int a = 1, b = 2, c = 3;
		leftRotate(a, b, c);
		cout << "leftRotate: a=" << a << ", b=" << b << ", c=" << c << "\n";

		int t = 41;
		inc(t); 
		cout << "inc(t): t=" << t << '\n';

		inc(inc(t)); 
		cout << "inc(inc(t)): t=" << t << '\n';
	}

	int main() 
	{
		test();
		return 0;
	}
	

Exercice 2 : template class
---------------------------

	* Créez un fichier nommé *5_template_class.cpp*

	* Créez une structure template *TupleN* stockant deux éléments numériques *a*, *b*
	
	* Ajoutez les fonctions membres suivantes :
	
		* constructeur par défaut qui met les deux valeurs à zéro
		* constructeurs paramétriques
		* *reset()*   qui remet à zéro les deux éléments
		* *sort()*  qui les tris dans l'ordre croissant
		* *positive()* qui retourne true si les deux éléments sont positifs
		* double getter
		* setter
		
	* Attention, MAXIMISEZ la présence du mot-clef const 
	
	* Uploadez le fichier  sur votre github