IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

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

Le , par Linunix

24PARTAGES

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 : Sélectionner tout
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
sort(v.begin(), v.end(), std::greater<Elem>());
Les foncteurs greaters, plus, multiplies :
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; }
};
À 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
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 ?

Une erreur dans cette actualité ? Signalez-le nous !