Closed GuillaumeBelz closed 2 years ago
Trop tard pour être publié
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
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.
Trop tard pour être publié
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
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.
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{ .... };
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>>
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.
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 : 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.
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 :
is
and as
", par Herb Sutter, le mardi 26 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).
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:
is
and as
" par Herb Sutter.Mercredi :
N'hésitez pas à partager vos programmes aussi.
issue precedente https://github.com/NotANameServer/discord/issues/30