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 |
sort(v.begin(), v.end(), [] (const Elem& l, const Elem& r) { return l > v; }
| Code : | Sélectionner tout |
sort(v.begin(), v.end(), std::greater<Elem>());
| Code : | Sélectionner tout |
1 2 3 4 | template<class T>
struct plus {
T operator()(const T& x, const T& y)
{ return x + y; } |
| Code : | Sélectionner tout |
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 |
1 2 3 4 5 | template<class T>
struct greater {
bool operator()(const T& x, const T& y)
{ return x > y; }
}; |
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 |
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<>()); |
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 ?