Licence CC BY-NC-SA

C++ TL;DR news 4

Enfin, c'est pas trop tôt !

L’inconvénient d’écrire des billets basés sur les lectures que je fais, c’est que je ne peux pas publier grand chose quand je ne lis pas d’articles pendant quelques temps. Bien sûr, j’ai lu dans le cadre de mon boulot, mais c’était trop spécifique pour faire entrer dans un billet.

Je vais donc laisser tomber la règle de la publication le lundi. Et toutes les règles. Les billets arriveront quand ils arriveront !

Une annonce importante : je ferais des lives sur Twitch pour la CppCon. Tout est expliqué dans la suite de ce billet, si cela vous intéresse.

Lisez les autres C++ TL;DR news : https://zestedesavoir.com/billets/3947/c-tl-dr-news/ l-dr-news/

  • [Pour tous] Quelques annonces sur la CppCon 2021.
  • [C++20] Un point un peu piégeux pour initialiser std::span avec une liste de valeurs.
  • [C++20] D’autres pièges sur std::optional.
  • [C++17] Un petit résumé du "Template Argument Deduction of Class Templates".
  • [Pour tous] Le Trip report de Herb Sutter pour le Summer 2021 ISO C++ standards meeting.

CppCon 2021

La CppCon commence la semaine prochaine (du 25 au 29 octobre 2021) https://cppcon2021.sched.com. Comme les années précédentes, je vais suivre cette conférence et comme l’année dernière, je le ferais en ligne. (Il est possible d’être présent sur place cette année, mais mon entreprise, pour des raisons sanitaires, à choisi de ne pas envoyer les personnes là bas).

Pour ceux que ça intéresse, je ferais des lives sur twitch (https://www.twitch.tv/gbdivers) pendant la semaine de cette conférence.

Au programme :

Tous les matins, un résumé des conférences que j’ai suivi la veille. Si d’autres personnes suivent la CppCon, ils sont chaleureusement invité à me rejoindre sur le discord NaN pour discuter en live. Les conférences commencent à 7h45 MDT (donc 15h45 en France), je ferais les lives vers 7h00 MDT (15h en France).

Live sur les keynotes

Il y a 6 keynotes au programme, mais pour le moment, seules 5 ont été annoncée.

  • "C++20: Reaching for the Aims of C++", par Bjarne Stroustrup, le lundi 25 octobre, de 8h45 MDT à 10h30 MDT (16h45 à 18h30 en France).
  • "Extending and Simplifying C++: Thoughts on pattern Matching using is and as", par Herb Sutter, le mardi 26 octobre, de 10h30 MDT à 12h MDT (18h30 à 20h en France).
  • "Value in a Procedural World", par Lisa Lippincott, le mercredi 27 octobre, de 10h30 MDT à 12h MDT (18h30 à 20h en France).

Je donne le détail des heures MDT et heure française, pour que vous puissiez me corriger si je me trompe.

Je pense que je ferais les keynotes en live sur twitch aussi.

Mon programme

De mon côté, il est possible que je suis la série de vidéos "Software Design". Mon programme de la semaine devrait être le suivant : https://cppcon2021.sched.com/gbelz

Pour ceux qui ne sont pas inscrit à la CppCon, les vidéos seront mis en ligne sur YouTube dans les semaines à venir https://www.youtube.com/user/CppCon. Si vous êtes débutants ou intermédiaires, je vous conseille la série de vidéos "Back to basics".

N’hésitez pas à partager vos programmes aussi.

std::span should have a converting constructor from initializer_list

Lire l’article : https://quuxplusone.github.io/blog/2021/10/03/p2447-span-from-initializer-list/

Cet article détaille la problématique de la création d’un std::span (C++17) à partir de liste de valeurs. Avec std::string_view, il est possible de passer une lvalue ou une rvalue :

void f(std::string_view);
void test() {
    std::string s = "hello";
    f(s);        // OK
    f("world");  // OK
}

Par symétrie, il serait intéressant de pouvoir écrire le même code avec std::span :

void f(std::span<const int>);
void test() {
    std::vector<int> v = {1, 2, 3};
    f(v);          // OK
    f({1, 2, 3});  // ...error??
}

Le problème est que std:: initializer_list ne peut pas être déduit par le constructeur de std::span. Il faut alors écrire explicitement :

f(std::vector{1, 2, 3});
f(std::array{1, 2, 3});
f(std::initializer_list<int>{1, 2, 3});

Des solutions sont proposées pour le C++23, mais il reste des problèmes à régler.

L’autre question abordée par l’article est le risque d’avoir une indirection invalide avec std::span (mais c’est valide avec tous les types similaires, dont std::string_view). Par exemple :

std::vector<int> getVector() { return {1, 2, 3}; }
std::span<const int> sp = getVector();
for (int i : sp) std::cout << i;  // UB, dangling pointer, possible segfault

Ce problème a fait l’objet de nombreux débats dans la communauté C++. Et la solution est simplement… ne pas faire ça !

Arthur utilise le concept de "parameter-only type", c’est-à-dire des types qui ne doivent servir que dans des paramètres de fonctions. Le propos de ces types est uniquement de simplifier des passages par référence constante : std::string_view à la place de const std::string& et std::span à la place de const std::vector& (ou d’autres types de tableaux).

En aucun cas, ces types doivent être utilisé en retour de fonction ou comme variable.

Some lesser-known powers of std::optional

Lire l’article : https://devblogs.microsoft.com/oldnewthing/20211004–00/?p=105754

Un article intéressant sur quelques pièges quand on utilise std::optional (C++17).

Par exemple si on essaie de comparer un std::optional<bool> ou std::optional<int> en pensant comparer la valeur contenue dans le std::optional :

std::optional<bool> opt1 = false;
if (opt1) {
    // this executes because the variable
    // is non-empty (even though it is false)
}

std::optional<int> opt;
if (opt == 0) {
    // does not execute because the variable is empty
    // and is not equal to any integer.
}

Pour lever les ambiguïtés, il faut alors utiliser has_value() et value().

Template Argument Deduction of Class Templates

Lire l’article : http://www.modernescpp.com/index.php/template-argument-deduction-of-class-templates

Cet article fait partie d’une série, qui vise à couvrir l’ensemble des syntaxes liées aux templates. Je te conseille de lire les autres articles si le sujet d’intéresse.

La déduction des paramètres template "non type"

Les paramétres template "non type" (non-type template parameters, je ne connais pas de traduction officielle) correspondent a des valeurs au lieu de types.

template <auto N>
class MyClass{
    ....
};

template <int N>
class MyClass<N> {
    ....
};

MyClass<'x'> myClass1;
MyClass<2017>  myClass2;

Les valeurs acceptées sont nullptr, les valeurs intégrales (integral value) comme les bool et les int, les références & (lvalue references), les pointeurs, les énumerations, et les nombres réels (C++20).

Les arguments "non type" peuvent également être utilisés avec les variadic template :

template <auto... ns> 
class VariadicTemplate{ .... }; 

template <auto n1, decltype(n1)... ns>
class TypedVariadicTemplate{ .... };

Déduction automatique des classes templates

Avant le C++17, seul la déduction automatique des fonctions template était possible, mais depuis le C++17, cela fonctionne aussi avec les classes templates.

// fonction template
template <typename T>
void showMe(const T& t);

showMe(5.5);          // not showMe<double>(5.5);
showMe(5);            // not showMe<int>(5);

// classe template
template <typename T>
struct ShowMe;

ShowMe(5.5);          // not ShowMe<double>(5.5);
ShowMe(5);            // not ShowMe<int>(5);

Quelques exemples avec la bibliothèque standard :

std::array myArr{1, 2, 3};         // deduces std::array<int, 3> 
std::vector myVec{1.5, 2.5};       // deduces std::vector<double>
 
std::mutex mut;
std::lock_guard myLock(mut);       // deduces std::lock_guard<mutex>(mut);
  
std::pair myPair(5, 5.5);          // deduces std::pair<int, double>
std::tuple myTup(5, myArr, myVec); // deduces std::tuple<int, 
                                   // std::array<int, 3>, std::vector<double>>

Déduction automatique avec les concepts

La déduction automatique fonctionne également avec les concepts (C++20).

void foo(auto t);
foo(5.5);

void bar(std::integral auto t);
bar(5);

template <std::regular T>
struct Class;
Class cl(true);

Trip report: Summer 2021 ISO C++ standards meeting (virtual)

Lire l’article : https://herbsutter.com/2021/06/09/trip-report-summer-2021-iso-c-standards-meeting-virtual/

Comme pour chaque réunion du comité C++, Herb Sutter a écrit un compte rendu des différentes propositions en cours de discussion ou acceptée. Pour rappel, il existe un document qui présente les priorités pour le C++23 et un autre qui présente le planning pour le C++23.


Comme la CppCon aura lieu la semaine prochaine, je ne ferai pas de nouveau billet tout de suite. Le prochain billet sera probablement consacré spécifiquement à la CppCon.

À la prochaine.

6 commentaires

C’est un peu dommage que std::span (au même titre que std::string_view) aient ces risques en cas d’utilisation en tant que variable plutôt que de paramètre. Ça contraste avec le temporary lifetime extension:

std::vector<int> getVector() { return {1, 2, 3}; }
std::span<const int> sp = getVector(); // sp non utilisable
const std::vector<int>& vref = getVector(); // pas de problème

D’un autre côté, pouvoir supporter l’équivalent pour un type arbitraire aurait encore complexifié une partie du langage qui est déjà très complexe.

Bon, comme j’ai loupé la première journée de la CppCon et que je n’ai pas forcément beaucoup a dire sur les confs (on est en période de transition, le C++20 est sorti et le C++23 en est qu’au début), je ne ferai pas de live tous les jours. Je ferais un live final samedi, pour parler de l’ensemble de la conf

De plus, j’aimerais refaire les Back to basic, comme j’avais commencé l’année dernière. Mais j’avais pensé a un nouveau format : au lieu de regarder les confs ensemble en live, j’avais envie de faire des exos sur chaque talk. Chacun regardera le talk dans la semaine (1 talk par semaine), puis je vous propose des exos en live. Certains seront courts, pour être fait en live et d’autres seront plus long, pour etre fait hors live.

Vous en pensez quoi ?

+2 -0

Salut @gbdivers ! Merci pour ce billet.

@mehdidou99 Je viens de découvrir par hasard que tu avais publié en 2019 les "Causeries C++". Si tu veux écrire de temps en temps des petits billets, on peut les inclures dans les TL;DR C++ si tu veux (qui ne sont finalement pas des TL;DR, vu leur longueurs…)

gbdivers

Avec plaisir, si j’ai des nouvelles idées de billets que je voudrais écrire je t’enverrai un message !

+1 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte