C++ TL;DR news 4

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.

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.

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().

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);

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.