search

NotANameServer / discord

Règles et gestion du serveur Discord de programmation Not a Name : https://discord.gg/zcWp9sC
23 stars 10 forks source link

C++ TL;DR news 4 #34

Closed GuillaumeBelz closed 2 years ago

GuillaumeBelz commented 3 years ago

issue precedente https://github.com/NotANameServer/discord/issues/30

GuillaumeBelz commented 3 years ago
GuillaumeBelz commented 3 years ago

Trop tard pour être publié

Learning solutions survey

Pour ceux que ça intéressé, voici un petit questionnaire réalisé par Qt Company, pour mieux connaitre le public de Qt. https://www.qt.io/blog/learning-solutions-survey

GuillaumeBelz commented 3 years ago

Three Myths About Floating-Point Numbers

Lire l'article : https://www.cppstories.com/2021/06/floating-point-myths/

peuvent avoir un impact sur la précision de certains calculs. Article pour aider a aller un peu plus loin.

GuillaumeBelz commented 3 years ago

Trop tard pour être publié

CppCon 2021 Call for Submissions

Lire l'article : https://cppcon.org/cppcon-2021-call-for-submissions/

Ce n'est pas une news qui va intéresser beaucoup de monde, mais la CppCon reste un événement majeur du C++. Et même si peu de monde aura l'occasion d'y aller (j'y serais probablement, vu que mon entreprise est sponsor de la CppCon), j'imagine que beaucoup connaissent et ont déjà vu les vidéos des conférences sur YouTube.

Si ce n'est pas le cas, je vous conseille de suivre cette chaîne, c'est une source d'information très intéressante en C++. Je vous conseille en particulier les sessions plénières (https://www.youtube.com/watch?v=ERzENfQ51Ck&list=PLHTh1InhhwT4PVVy3PGfw0Va7wZNrH0-w), les Back to basic (https://www.youtube.com/watch?v=ZAji7PkXaKY&list=PLHTh1InhhwT5o3GwbFYy3sR7HDNRA353e) et ma recommandation personnelle : "Stop Teaching C" de Kate Gregory (https://youtu.be/YnWhqhNdYyk?list=PUMlGfpWw-RUdWX_JbLCukXg).

La chaine YouTube : https://www.youtube.com/user/CppCon

GuillaumeBelz commented 3 years ago

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);
GuillaumeBelz commented 3 years ago

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.

GuillaumeBelz commented 2 years ago

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

GuillaumeBelz commented 2 years ago

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.

GuillaumeBelz commented 2 years ago

CppCon 2021

La CppCon commence dans très peu de temps : dans 16 jours (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 (je donnerais les liens vers la chaîne NaN une autre fois, il parait qu'il y a des problèmes en ce moment avec twitch...) 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).

Regarder en live les keynotes suivi d'une discussion. Les 3 keynotes sont :

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

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

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.

Lundi :

Mardi:

Mercredi :

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