Going Native 2013 - Stephan Lavavej - Don't help the compiler

Le 2013-09-14 16:38:33, par Linunix, Membre confirmé

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 :

Rediffusion de la conférence

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 :

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 :

sort(v.begin(), v.end(), std::greater<Elem>());

Les foncteurs greaters, plus, multiplies :

Code :

1
2
3
4
template<class T>
struct plus {
T operator()(const T& x, const T& y)
{ return x + y; }

Code :

1
2
3
4
5
template<class T>
struct multiplies {
T operator()(const T& x, const T& y)
{ return x * y; }
};

Code :

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 :

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é.

Conférence précédente : A. Alexandrescu, Writing Quick Code in C++, Quickly

Évènement : GoingNative 2013

Et vous
Qu'en pensez-vous ?