Stephan Lavavej - Don't help the compiler
GoingNative 2013

La conf�rence de Stephan. T. Lavavej (alias S.T.L.) lors des GoingNative 2013 est maintenant disponible en rediffusion :


Voici un r�sum� de cette conf�rence :

Les lambdas ne sont pas toujours mieux

Utilisez certains foncteurs plut�t que des lambdas.

Que pensez-vous de ce code ?
Code : S�lectionner tout - Visualiser dans une fen�tre � part
sort(v.begin(), v.end(), [] (const Elem& l, const Elem& r) { return l > v; }
Eh bien, Lavavej explique qu'il est verbeux. En effet, il pr�conise l'utilisation du foncteur greater dans ce cas l�, de la mani�re suivante :
Code : S�lectionner tout - Visualiser dans une fen�tre � part
sort(v.begin(), v.end(), std::greater<Elem>());
Les foncteurs greaters, plus, multiplies :
Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
4
template<class T>
struct plus {
T operator()(const T& x, const T& y)
{ return x + y; }
Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
4
5
template<class T>
struct multiplies {
T operator()(const T& x, const T& y)
{ return x * y; }
};
Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
4
5
template<class T>
struct greater {
bool operator()(const T& x, const T& y)
{ return x > y; }
};
� travers ces codes S.T.L. veut nous montrer la simplicit� d'utilisation de ces foncteurs par rapport aux lambdas qui sont plus verbeuses. Utiliser certains foncteurs int�ressants et utiles (greater, less, plus, multiplies, et d'autres...) permet de gagner grandement en lisibilit�.


Les diamonds

Au cours de cette conf�rence, Stephan T. Lavavej a �galement pr�sent�, un nouveau type de foncteurs, nomm�s "diamonds" sur lesquels il travaille.

Il a effectu� une proposition pour la standardisation du C++14. Voici un code d'exemple d'utilisation :

Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
4
vector<const char *> v { "cute", "fluffy", "kittens" };
set<string, greater<>> s { "Hungry", "EVIL", "ZOMBIES" };
vector<string> dest;
transform(v.begin(), v.end(), s.begin(), back_inserter(dest), plus<>());
Gr�ce aux codes suivants, avec les conteneurs vector et set, ainsi que l'algorithme transform, Lavavej explique, et prouve leur simplicit� d'utilisation, ainsi que leur c�t� extr�mement pratique.


En r�sum� :
Utilisez les foncteurs "diamonds" lorsqu'ils seront disponibles, cela am�liorera la lisibilit�.
En plus d'�tre moins verbeux, ils sont plus efficaces et permettent d'�viter les divers dangers de conversion de types.


L'utilit� du const X&&

Dans cette petite partie, S.T.L. nous explique que :

  • const X&& n'est pas utile pour la s�mantique de d�placement ;
  • const X&& n'est pas parfait pour le transfert parfait �galement ;
    Except� X&& qui d�clenche la d�duction d'argument d'un template.


Cependant, const X&& permet de rejeter des temporaires.

Synth�se g�n�rale :
  • Apprenez � utiliser les r�f�rences rvalues.

  • Ne surchargez pas les transferts parfaits, car ils sont intentionnellement gourmands.

  • Utilisez les temporaires seulement quand ils sont n�cessaires.

  • Utilisez "const X&&" pour rejeter les temporaires

  • Mais surtout essayez d'�crire du code uniquement lorsque vous savez comment celui-ci va se comporter. Cela am�liore votre conception et r�duit le nombre de modifications apport�es � votre code par rapport � un d�veloppement sans r�flexion.

    C'est g�n�ralement vrai, mais sp�cialement pour les r�f�rences rvalues, sinon veuillez demander, ou vous faire conseiller par un expert.

  • Utilisez certains foncteurs (greater, plus, multiplies, less, etc...), plut�t que les lambdas qui nuisent � la lisibilit�.


�v�nement : GoingNative 2013

Et vous
Qu'en pensez-vous ?