C++ – Bases, culture et pédagogie

Les liens qui suivent mènent pour l'essentiel vers des sites et articles discutant des bases du langage C++, ou ayant une vocation pédagogique quant à ce langage.

Ressources et textes d'introduction

• Démarer avec C++ : https://isocpp.org/get-started
• Quelques ressources recommandées (et recommandables) pour apprendre C++ :
  • http://isocpp.org/get-started
  • http://www.cprogramming.com/
  • http://www.cppsamples.com/
  • quelques propositions de Shafik Yaghmour en 2019 : https://shafik.github.io/c++/learning/2019/09/05/getting_started_learning_cpp.html
  • quelques bibliothèques : http://www.trumphurst.com/cpplibs/cpplibs.php
• http://derwiki.tumblr.com/post/98651197/what-i-wish-i-had-known-about-developing-c-c-from
• Réapprendre C++ après l'avoir quitté pendant plusieurs années, un texte de Josh Reuben en 2011 : http://geekswithblogs.net/JoshReuben/archive/2011/10/29/post-build-c-skill-rebuild.aspx
• Dans les mots de l'auteur, Jordan DeLong, C++, The Good Parts, une présentation de 2013 : http://qconsf.com/system/files/presentation-slides/C%2B%2B_good_parts.pdf
• Un glossaire : http://www2.research.att.com/~bs/glossary.html
• Considérations globales sur le langage : http://www.parashift.com/c++-faq-lite/big-picture.html
• S'acclimater à C++ en tant que programmeuse ou en tant que programmeur, texte de Manu Sánchez en 2015 : http://blog.biicode.com/the-pragmatic-cpp-programmer/
• Que faut-il connaître pour se considérer une programmeuse ou un programmeur C++ « intermédiaire »? Texte de Jeff Cogswell en 2015 : http://insights.dice.com/2015/06/22/what-to-know-for-intermediate-c/
• En 2015, Sasha Goldshtein donne ses recommandations à celles et ceux qui ne se sont pas encore mis à jour vers le C++ moderne (C++ 11 et plus récent) : http://blogs.microsoft.co.il/sasha/2015/08/15/why-you-have-to-learn-modern-c/
• Plusieurs algorithmes (de tri, principalement, comme std::sort()) et plusieurs conteneurs (surtout les conteneurs associatifs comme std::map) exigent des types pour lesquels un ordonnancement faible et strict (Strict Weak Ordering) est possible. Pour comprendre ce que cela signifie :
  • http://cpp-next.com/archive/2010/02/order-i-say/
  • http://www.sgi.com/tech/stl/StrictWeakOrdering.html
• Comprendre pourquoi compiler un programme C++ peut être long (de Walter Bright) : http://www.drdobbs.com/blog/archives/2010/08/c_compilation_s.html
• Grammaire de C++ :
  • http://weegen.home.xs4all.nl/eelis/cppgrammar.png
  • comment Clang traite une ambiguïté subtile de cette grammaire, par Eli Bendersky en 2012 : http://eli.thegreenplace.net/2012/07/05/how-clang-handles-the-type-variable-name-ambiguity-of-cc/
• Programmer avec C++ serait un geste moral et environnemental, texte de 2014 : http://mempko.wordpress.com/2014/04/01/c-and-climate-change/
• Quelques pièges qui attendent la « nouvelle » programmeuse ou le « nouveau » programmeur C++, répertoriés par Florian Weber : http://florianjw.de/en/modern_cpp.html
• En 2016, Stephanie Hurlburt suggère d'apprendre C++ en réalisant des tâches concrètes : http://stephaniehurlburt.com/blog/2016/5/29/learning-c-as-you-go
• Texte de 2019 dans lequel Jan Wilmans explique son cheminement pour apprendre C++ : http://nullptr.nl/2019/01/better-cpp-software-engineer/

Généralités

Liens sur des sujets d'ordre général :

• Aide en ligne « officielle » à toutes fins pratiques : http://cppreference.com/
• Foire aux questions officielle : http://isocpp.org/faq
• Le langage selon son auteur, Bjarne Stroustrup :
  • http://www2.research.att.com/~bs/C++.html
  • à propos de C++ 11 plus spécifiquement : http://www.stroustrup.com/C++11FAQ.html
  • http://www.codeguru.com/cpp/misc/article.php/c18357/An-Interview-with-C-Creator-Bjarne-Stroustrup.htm
  • http://electronicdesign.com/dev-tools/interview-bjarne-stroustrup-discusses-c
  • http://developers.slashdot.org/article.pl?sid=00/02/25/1034222&mode=nocomment
  • http://www.infoworld.com/t/application-development/stroustrup-why-the-35-year-old-c-still-dominates-real-dev-248457
  • ce que C++ 14 apporte de neuf, entrevue avec Michael Wong en 2014 : http://electronicdesign.com/dev-tools/bjarne-stroustrup-talks-about-c14
  • séance de questions/ réponses publique en 2014 : http://features.slashdot.org/story/14/08/20/011231/interviews-bjarne-stroustrup-answers-your-questions
  • entrevue avec Richard Morris en 2014 : https://www.simple-talk.com/opinion/geek-of-the-week/bjarne-strostrup,-and-programmers-with-class/
• En 2014, Bjarne Stroustrup disserte sur une série de mythes à propos de C++ : http://www.stroustrup.com/Myths-final.pdf
• Quelques Wikis utiles :
  • http://en.wikipedia.org/wiki/C++
  • http://en.wikibooks.org/wiki/Category:C++_programming_language
  • http://en.wikipedia.org/wiki/C_Plus_Plus_standard_library
  • http://en.wikipedia.org/wiki/Standard_Template_Library
• http://www.cppreference.com/wiki/
• Excellente référence pour C et C++ : http://en.cppreference.com/w/Main_Page
• http://www.cplusplus.com/
• Un outil pratique pour naviguer à travers les bibliothèques standards (merci à Bill Christian Tyros pour le lien) : http://devdocs.io/cpp/header
• http://www.cs.bsu.edu/homepages/peb/cplusplus/headers/default.htm
• Pages sur C++ de Nathan Myers :
  • http://www.cantrip.org/
  • http://www.cantrip.org/cpp.html
  • http://www.cantrip.org/realworld.html
  • http://www.cantrip.org/stdlibif.html
  • http://www.cantrip.org/gnarly.html
• Quelques idées et quelques trucs :
  • http://h-deb.ca/Sujets/Divers--cplusplus/index.html
• Une foire aux questions (merci à Étienne de Martel pour ce lien)
• http://cs.stmarys.ca/~porter/csc/ref/cpp_standlib.html, qui ne couvre pas STL
• Une carte de la documentation disponible sur C++
• Introduction au C++ contemporain, présentation d'Olve Maudal en 2014 : http://www.pvv.org/~oma/ModernCPP_Thales_Oct2014.pdf
• Faire évoluer C++ sans en altérer l'intégrité conceptuelle, une courte réflexion de Tony Da Silva en 2015 : http://bulldozer00.com/2015/05/04/the-annihilation-of-conceptual-integrity/
• Expérience de migration à très grande échelle, relatée par Terry Crowley en 2017 : https://hackernoon.com/taking-office-cross-platform-from-inside-the-windows-company-42c39fa638f5
• Quelques acronymes communs dans le monde de C++ :
  • https://en.cppreference.com/w/cpp/language/acronyms
  • liste colligée par Arthur O'Dwyer en 2019 : https://quuxplusone.github.io/blog/2019/08/02/the-tough-guide-to-cpp-acronyms/

Programmation fonctionnelle en C++ : ../../Liens/Paradigmes-programmation--Liens.html#programation_fonctionnelle_langage_Cplusplus

Enseignement

Enseigner C++ :

• http://www.two-sdg.demon.co.uk/curbralan/papers/TheMiseducationOfC++.pdf
• http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=542
• Comment mal enseigner C++?
  • généralités : http://drdobbs.com/blogs/cpp/229401490
  • mal utiliser les tableaux : http://drdobbs.com/blogs/cpp/229401975
  • texte de... 2001, par Kevlin Henney, mais toujours d'actualité : http://fr.slideshare.net/Kevlin/the-miseducation-of-c
• C++ n'est pas un langage OO, du moins pas strictement et pas dans le sens « traditionnaliste » du terme, comme le rappelle Arne Mertz dans ce texte de 2015 : http://arne-mertz.de/2015/07/c-is-not-an-object-oriented-language/
• En 2018, Borislav Stanimirov recommande de ne pas enseigner C++... à titre de premier langage : https://ibob.github.io/blog/2018/11/22/stop-teaching-cpp/
• Texte de 2018 par Marius Elvert, qui exprime sa vision du bon  enseignement de C++ : https://schneide.blog/2018/11/22/how-to-teach-c/
• Réflexions de Simon Brand en 2017 sur la question de l'apprentissage de C++ : https://blog.tartanllama.xyz/learning-cpp/
• En 2019, l'équipe de PVS Studio souligne qu'il est encore important d'apprendre C et C++ : https://hownot2code.com/2019/04/30/reasons-why-you-should-keep-learning-c-c/

Culture et histoire

À propos des aspects culturels et historiques du langage :

• Histoire de ce langage :
  • un morceau d'histoire : http://www.softwarepreservation.org/projects/c_plus_plus/paper/AttCppArticle.pdf
  • http://www.computerworld.com.au/article/250514/-z_programming_languages_c
  • http://www2.research.att.com/~bs/hopl-almost-final.pdf
  • http://www.softwarepreservation.org/projects/c_plus_plus
  • d'où viennent les diverses caractéristiques et fonctionnalités de C++? Texte Tony DaSilva en 2014 : http://bulldozer00.com/2014/10/05/on-the-origin-of-features/
  • vision par époques de l'évolution de C++, proposée R. Martinho Fernandes en 2014 : http://flamingdangerzone.com/cxx11/2014/10/28/history-of-c++.html
  • texte de Bjarne Stroustrup et d'Andrew Koenig, en 1989, expliquant pourquoi ils préconisaient de tenir C++ aussi près que possible de C... Mais pas plus : https://isocpp.org/files/papers/N0007.pdf
  • pour le 30^e anniversaire de Cfront, le premier compilateur C++, Aurélien Regat-Barrel retrace, avec Bjarne Stroustrup, l'histoire de ce langage : http://cpp-lang.io/30-years-of-cpp-bjarne-stroustrup/
    • Cfront générait du code C et a été abandonné quand les exceptions ont été ajoutées à C++. D'ailleurs, en 2015, Andrey Karpov fait une analyse statique de Cfront, pour s'amuser : http://www.i-programmer.info/programming/cc/9212-finding-bugs-in-the-first-c-compiler-what-does-bjarne-think.html
  • texte de 2016 présentant le point de vue d'un programmeur du monde des systèmes embarqué sur la modernisation du code C++ : https://www.esrlabs.com/blog/c-now-and-in-the-future/
• Le pays de C++ :
  • http://fearlesscoder.blogspot.ca/2012/01/c11-lands.html (pour C++ 11)
  • http://fearlesscoder.blogspot.ca/2017/02/the-c17-lands.html (pour C++ 17)
• C++ est-il vraiment utilisé? à vous de voir :
  • http://www2.research.att.com/~bs/applications.html
  • http://blogs.msdn.com/b/vcblog/archive/2014/02/21/why-c.aspx
  • http://www.stroustrup.com/GamesListOfCpp.pdf
• Pourquoi C++ n'est pas si mal que ça, finalement :
  • http://efxam.blogspot.com/2009/10/why-c-doesnt-suck.html
  • http://www.hanselman.com/blog/CKilledMyGrandpappyIsCHardAndWhereAreTheCCodersHiding.aspx
  • le monde repose sur C++, en quelque sorte : http://m.theregister.co.uk/2011/06/11/herb_sutter_next_c_plus_plus/
  • où C++ est-il utilisé? David Intersimone propose une compilation en 2013 : http://blogs.embarcadero.com/davidi/2013/02/26/42586
  • en 2014, John Thomas se dit d'avis que C++ est le langage idéal pour le développement d'applications, au sens large du terme : http://betanews.com/2014/07/22/why-c-is-the-perfect-choice-for-modern-app-development/
  • à propos de l'importance de l'enseignement de l'ingénierie logicielle, et de C++ par le fait-même, article de C. D. Mote Jr. en 2018 : http://thehill.com/opinion/education/373649-highlighting-the-e-in-stem-education
• Truc un peu vilain : le Grand C++ Error Explosion Competition, un concours pour générer le plus grand nombre d'erreurs possible à la compilation avec le moins d'instructions possible. http://tgceec.tumblr.com/post/74534916370/results-of-the-grand-c-error-explosion-competition
• L'impact très positif de C++ 11, texte de Tony DaSilva en 2014 : http://bulldozer00.com/2014/06/16/game-changer/
• En 2015, Kenny Kerr se demande si nous entrons dans un âge d'or (au sens anglais de Golden Age) ou dans un âge sombre (Dark Ages) de C++ : http://kennykerr.ca/2015/05/26/a-second-dark-age-for-c/
• C++ est-il un langage du passé ou du futur? Réflexion d'Arne Mertz en 2015 : http://arne-mertz.de/2015/06/the-state-of-c-is-it-back-or-not/
• Approcher C++ comme un langage de script, texte de 2015 par A. Sinan Unur : http://www.nu42.com/2015/05/cpp-new-scripting-language.html
• Démarrer une entreprise sur la base du développement en C++, cas vécu relaté par James Perry en 2016 : https://medium.com/swlh/starting-a-tech-startup-with-c-6b5d5856e6de
• En 2016, Bruce Bye relate son passage à Meeting C++ 2016, où il s'est présenté en sceptique provenant du monde du langage C : http://undo.io/resources/blog-articles/cpp-confessions-of-a-c-dev/
• Le code source de Cfront, qui a longtemps été le compilateur C++ de référence : http://www.softwarepreservation.org/projects/c_plus_plus/cfront
• En 2017, Jens Weller réfléchit sur ce que deviendra C++... en 2017, justement : http://meetingcpp.com/index.php/br/items/cpp-in-2017.html

Technique

Voici quelques articles techniques d'ordre général, qui ne tombent pas directement dans l'une ou l'autre des autres rubriques.

• Système de types de C++ : ../../Liens/Systemes-types--Liens.html#langage_Cplusplus
• Liste des symboles de la blbiothèque standard de C++ 03 : http://www.bobarcher.org/software/C++98%20Symbols.html
• Liste des symboles de la blbiothèque standard de C++ 11 : http://www.bobarcher.org/software/C++11%20Symbols.html
• Introduction aux structures de contrôle du langage, texte de 2014 : http://www.lifengadget.com/lifengadget/control-structures-in-cplusplus/
• Quelques quiz de connaissances dans ce langage :
  • http://www.lifengadget.com/lifengadget/quiz-basic-c-1/
  • http://cppquiz.org/quiz/question/1
• Méthodes virtuelles :
  • polymorphisme avec C++ : ../Sujets/Divers--cplusplus/Polymorphisme.html
  • ce que signifie un « appel de méthode pure virtuelle » : http://www.artima.com/cppsource/pure_virtual.html
  • pourquoi il ne faut jamais invoquer une méthode virtuelle sur un objet pendant sa construction ou sa destruction : http://www.artima.com/cppsource/nevercall.html
• Parcourir un répertoire UNIX avec des itérateurs : http://www.artima.com/cppsource/randomdirectories.html
• Article du Code Project sur l'effacement de types et le typage dynamique : http://www.codeproject.com/kb/cpp/dynamic_typing.aspx
• Article du Code Project sur les délégués : http://www.codeproject.com/kb/cpp/ImpossiblyFastCppDelegate.aspx
• Quelques passages du très bon C++ Coding Standards, par Herb Sutter et Andrei Alexandrescu : http://www.artima.com/cppsource/codestandards.html
• Trucs d'optimisation en C++ : http://h-deb.ca/Liens/Optimisation--Liens.html#optimisation_c_cpp
• Les métafonctions : http://www.artima.com/cppsource/metafunctions.html
• Des λ (avant leur inclusion dans C++ 11), par Matthew Might : http://matt.might.net/articles/lambda-style-anonymous-functions-from-c++-templates/
• Transformer constante énumérée en string et vice versa :
  • article du Code Project : http://www.codeproject.com/KB/cpp/StringizingCppEnums.aspx
  • autre approche, par Walter Bright : http://www.drdobbs.com/blog/archives/2010/06/the_x_macro.html
• Utiliser XML avec C++ : ../Sujets/Web/XML-etc.html#langage_Cplusplus
• Traverser des structures hétérogènes avec C++ : http://www.dre.vanderbilt.edu/~sutambe/documents/pubs/LEESA-DSL09.pdf
• Prudence avec les variables non-initialisées, et en particulier avec les booléens : http://mlangc.wordpress.com/2010/07/18/when-true-is-not-true-anymore/
• Contrôler des composants Flash avec C++, article du Code Project : http://www.codeproject.com/KB/COM/flashcontrol.aspx
• Rédiger des énumérateurs paresseux (Lazy) : http://www.simonask.dk/blog/cpp-can-have-lazy-lambda-enumerators-too
• Résoudre un problème en définissant un DSL interne à C++ : http://cpp-next.com/archive/2010/09/expressive-c-playing-with-syntax/
• Écrire un interpréteur Lisp en C++ : http://howtowriteaprogram.blogspot.com/2010/11/lisp-interpreter-in-90-lines-of-c.html
• Micro manuel pour Lisp implémenté en C++ : http://badbyteblues.blogspot.com/2010/09/micro-manual-for-lisp-in-c.html
• Les littéraux analogues multidimensionnels (une bizarrerie amusante) : http://www.xs4all.nl/~weegen/eelis/analogliterals.xhtml
• Si vous aimez la syntaxe de passage de messages d'Objective-C, voici un article du Code Project montrant comment il est possible de l'implémenter (avec C++ 11; ça se fait avec C++ 03, mais c'est moins agréable) : http://www.codeproject.com/KB/cpp/cpp0x_message_passing.aspx
• Automatiser la « mémoisation » avec C++ 11 : http://slackito.com/2011/03/17/automatic-memoization-in-cplusplus0x/
• Utiliser C++ pour développer sous Windows :
  • http://msdn.microsoft.com/en-us/magazine/hh288076.aspx
  • http://msdn.microsoft.com/en-us/visualc/hh312793.aspx
  • intégrer C++ et le Powershell : http://csharpening.net/?p=689
• Intégrer les systèmes de types de C++ et de Haskell, texte d'Arjun Comar en 2014 : http://www.acomar.net/posts/2014-04-25-Foreign-CPP-Useful-Types-For-CPP-Interop.html (notez que ça ne donne pas nécessairement du C++ idiomatique!)
• Déduire le nombre d'éléments d'un tableau, à l'aide de techniques de programmation générique. Textes de Pete Barber en 2011 et en 2012 :
  • http://petebarber.blogspot.com/2011/11/obtaining-size-of-c-array-using.html
  • http://petebarber.blogspot.com/2011/12/obtaining-size-of-c-array-using.html
• Réduire les copies inutiles par Copy Elision, un texte de David Rodriguez en 2011 : http://definedbehavior.blogspot.ca/2011/08/value-semantics-copy-elision.html
• Générer du bruit de Perlin, texte de Paul Silisteanu en 2012 : http://solarianprogrammer.com/2012/07/18/perlin-noise-cpp-11/
• Comprendre std::terminate(), texte d'Andrzej Krzemieński en 2012 : http://akrzemi1.wordpress.com/2011/10/05/using-stdterminate/
• Évaluer des FFT à la compilation, un texte de Paul Keir en 2012 : http://paulkeir.wordpress.com/2012/09/02/a-compile-time-fft-in-c11/
• Un interpréteur statique (oui!) brainfuck en métaprogrammation, par Tony Young en 2012 : http://blog.rfw.name/2012/11/12/brainfuck_with_templates.html
• Construire un système de types  dynamiques en C++, une ébauche proposée en 2012 (je ne suis pas convaincu que ce soit très idiomatique de C++, cela dit) : http://crazycpp.wordpress.com/2012/12/29/arbitrary-binding-pt2-rolling-your-own/
• Des fractals avec C++ 11, texte de Paul Silisteanu en 2013 : http://solarianprogrammer.com/2013/02/28/mandelbroot-set-cpp-11/
• Les 22 (oui, vous avez bien lu!) façons de passer un paramètre à une fonction en C++, selon Sumant Tambe en 2013 : http://cpptruths.blogspot.ca/2013/09/21-ways-of-passing-parameters-plus-one.html
• Convertir une chaîne de caractères en entier, comparatif de plusieurs approches, colligé en 2013 : http://www.kumobius.com/2013/08/c-string-to-int/
• En 2013, Raymond Chen rapelle que C++ permet non seulement de déclarer une méthode abstraite, mais aussi de la définir. Tristement, ni lui, ni les commentatrices et les commentateurs n'expliquent clairement en quoi cette pratique est raisonnable... Car elle l'est! En effet, parfois, on veut que les classes dérivées implémentent une méthode, mais on souhaite quand même offrir une implémentation par défaut de cette méthode (en particulier, dans le cas d'un destructeur) : http://blogs.msdn.com/b/oldnewthing/archive/2013/10/11/10455907.aspx
• Quelques choses que peu de gens savent sur ce langage :
  •  http://madebyevan.com/obscure-cpp-features/?viksra
  • http://cogitolearning.co.uk/?p=1669
• Réduire les dépendances, et par le fait-même le temps de compilation :
  • texte de Steve Love en 2010 décrivant une technique pour réduire les impacts de changements de versions d'objets exposés par une DLL : http://accu.org/index.php/journals/1718
  • petit quiz proposé par Herb Sutter :
    • question : http://herbsutter.com/2013/08/12/gotw-7a-minimizing-compile-time-dependencies-part-1/
    • réponse : http://herbsutter.com/2013/08/19/gotw-7a-solution-minimizing-compile-time-dependencies-part-1/
    • question : http://herbsutter.com/2013/08/19/gotw-7b-minimizing-compile-time-dependencies-part-2/
    • réponse : http://herbsutter.com/2013/12/31/gotw-7b-solution-minimizing-compile-time-dependencies-part-2/
    • question : http://herbsutter.com/2013/12/31/gotw-7c-minimizing-compile-time-dependencies-part-3/
    • réponse : http://herbsutter.com/2014/01/06/gotw-7c-solution-minimizing-compile-time-dependencies-part-3/
  • tester efficacement du code C++, texte de Clarke Nelson en 2013 : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3745.htm
  • n'inclure que ce que l'on utilise vraiment, un conseil de Nicholas Nethercote en 2013 : https://blog.mozilla.org/nnethercote/2013/08/13/using-include-what-you-use/
• Définir un type scope, ayant un comportement semblable à celui qu'on rencontre en D, un texte de Nicolas Guillemot en 2013 : http://cppsecrets.blogspot.ca/2013/11/ds-scope-statement-in-c.html
• Un piège sournois relevé par Andrzej Krzemieński en 2014 : http://akrzemi1.wordpress.com/2014/03/20/strings-length/
• Intervalles :
  • présentation par Steve Love en 2014 : http://accu.org/content/conf2014/SteveLoveRange.pdf
  • travaux sur les intervalles, par Eric Niebler en 2014 :
    • intervalles délimités : http://ericniebler.com/2014/02/16/delimited-ranges/
    • intervalles infinis : http://ericniebler.com/2014/02/18/infinite-ranges/
    • itérables : http://ericniebler.com/2014/02/21/introducing-iterables/
    • et pour la suite... http://ericniebler.com/2014/02/27/ranges-infinity-and-beyond/
    • exprimer des intervalles comme des compréhensions de listes : http://ericniebler.com/2014/04/27/range-comprehensions/
• Quelques subtilités plus obscures du langage, colligées par Apie Mane en 2014 : http://aurisc4.blogspot.ca/2014/03/darkest-corners-of-c.html
• Utiliser C++ pour le développement sur plusieurs plateformes mobiles, l'exemple de Dropbox relaté par Ole Begemann en 2014 : http://oleb.net/blog/2014/05/how-dropbox-uses-cplusplus-cross-platform-development/
• Implémenter un système de signaux, réminescent de celui de Qt, par Adrien Hamelin en 2014 : https://aboutcpp.wordpress.com/2014/12/20/a-simple-signal-system/
• Des trucs de programmation :
  • quelques trucs jugés « obscurs » (certains illégaux, alors prudence!), colligés par Evan Wallace : http://madebyevan.com/obscure-cpp-features/
  • série de trucs colligée par Marius Bancilla en 2015 : http://www.codeproject.com/Articles/1035313/Cplusplus-is-fun-tips-and-tricks
• Accélérer la compilation de programmes C++, une série proposée par Krzysztof Szatan en 2017 :
  • http://itscompiling.eu/2017/01/12/precompiled-headers-cpp-compilation/
  • http://itscompiling.eu/2017/02/19/speed-cpp-compilation-compiler-cache/
  • http://itscompiling.eu/2017/03/19/speed-up-c-compilation-distributed-work/

Bas niveau

C++ à un niveau plus bas :

• Comprendre C++ à bas niveau : http://www.blackhat.com/presentations/bh-dc-07/Sabanal_Yason/Presentation/bh-dc-07-Sabanal_Yason.pdf
• Le modèle machine de C++ : http://www2.research.att.com/~bs/abstraction-and-machine.pdf
• Représenter efficacement le matériel en C et en C++ standard : http://www.open-std.org/jtc1/sc22/wg21/docs/ESC_SF_02_465_paper.pdf
• Réduire les délais dans des systèmes embarqués écrits en C++ : http://www.open-std.org/jtc1/sc22/wg21/docs/ESC_SF_02_405_&_445_paper.pdf
• Pourquoi utiliser C++ dans les systèmes embarqués? Un texte de Scott Meyers en 2010 : http://aristeia.com/TalkNotes/MISRA_Day_2010.pdf
• Selon Clay Stuart en 2012, avec l'avènement de multiples plateformes, en particulier les plateformes mobiles et leurs besoins en termes d'économie d'énergie, C++ serait le langage du futur : http://claystuart.blogspot.ca/2012/01/language-of-future-is-c.html (tous ne sont pas d'accord, par exemple Andrew Binstock en 2013 : http://www.drdobbs.com/jvm/the-rise-and-fall-of-languages-in-2012/240145800)
• Pourquoi le standard de C++ ne parle par de lieux (Storage Location) mais bien de durées (Storage Duration) pour les variables, un plaidoyer pour éviter de parler de « pile » et de « tas » de manière impropre en programmation, par Simon Brand en 2016 : https://tartanllama.github.io/c++/2016/07/18/stack-and-heap/

Moderne

Il semble d'usage de qualifier de « moderne » le code C++ qu'il est possible d'exprimer depuis C++ 11, bien qu'il existe aussi une bibliothèque portant ce nom. Ce nom a été introduit (je pense) par Andrei Alexandrescu dans Modern C++ Design, mais je pense que son sens a changé (évolué?) depuis et porte une nouvelle teinte suivant la publication d'Effective Modern C++ par Scott Meyers :

• Texte de 2015 par Mike P., qui décrit ce que signifie à ses yeux moderniser le code (et sa définition rejoint ce que permet de faire le code C++ moderne) : https://software.intel.com/en-us/articles/what-is-code-modernization
• Éviter de s'empêtrer dans la complexité avec le C++ moderne, une présentation de 2015 par Victor A. Laskin : http://vitiy.info/Slides/MeetingCPP2015/assets/player/KeynoteDHTMLPlayer.html#0
• En 2016, Philippe Desjardins-Proulx  met en relief à quel point l'écriture moderne de code C++ simplifie la tâche des programmeuses et des programmeurs : http://phdp.github.io/posts/2016-06-28-not-your-grandmother-cpp.html
• Certains se questionnent sur le sens à donner à l'appellation (maintenant consacrée) de C++ « moderne ». C'est une question plus profonde qu'il n'y paraît à première vue :
  • en particulier, ce texte de Jens Weller en 2016 : http://meetingcpp.com/index.php/br/items/what-does-modern-c-really-mean.html
• Profiter du C++ moderne pour réduire les bogues dans nos programmes, par Pavel Belikov en 2016 : http://www.viva64.com/en/b/0429/
• Réflexion de Phil Nash en 2015 sur ce que signifie écrire du code C++ « moderne » depuis l'avènement de C++ 11 : http://accu.org/index.php/journals/2064
• C++ et le monde « moderne », par Sergey Vasiliev en 2015 : https://medium.com/@CPP_Coder/c-in-the-modern-world-ce6f470dfbe0
• Bénéficier du C++ moderne, mais sans devenir fou, un texte de Bartlomiej Filipek en 2017 : http://www.bfilipek.com/2017/02/how-to-stay-sane-with-modern-c.html
• En 2017, Rainer Grimm essaie de définir ce que signifie le C++ « moderne » : http://www.modernescpp.com/index.php/what-is-modern-c
• Toujours en 2017, Rainer Grimm offre un plaidoyer pour des guides destinés à faciliter l'accession au C++ « moderne » pour les novices : http://www.modernescpp.com/index.php/why-do-we-need-guidlines-for-modern-c
• Découvrant le C++ « moderne » en 2017, l'auteur de ce texte exhorte les programmeuses et les programmeurs de s'approprier les nouveaux idiomes et les nouveaux outils de ce langage : http://cppdepend.com/blog/?p=171
• En 2016, David Bolton présente le C++ « moderne » à partir de quelques exemples : http://uk.dice.com/technews/modern-c-examples/
• Dans ce texte de 2018, Mathieu Ropert explique qu'il est possible d'écrire du code C++ « moderne » même en se limitant à C++ 03 : https://mropert.github.io/2018/02/25/modern_cpp_03/
• Migrer un système embarqué vers une version C++ « moderne », par Phillip Johnston en 2016 : https://embeddedartistry.com/blog/2016/10/18/migrating-to-modern-c
• Texte de 2018 par Arne Mertz, qui rappelle de programmer en C++ « moderne » n'est pas nécessairement équivalent à « programmer avec le tout dernier standard » : https://arne-mertz.de/2018/08/modern-c-newest-standard/

Critiques

Je vous invite à lire ces critiques... avec un esprit critique, sans mauvais jeu de mots, car certaines sont un peu grossières, mais tout n'est (évidemment) pas si sombre...

• http://www.mindspring.com/~blackhart/Re%20%20C++%20-%20The%20COBOL%20of%20the%2090s.html
• http://cpptruths.blogspot.com/2005/10/whats-wrong-with-c.html
• http://www.mistybeach.com/articles/WhyIDontLikeCPlusPlusForLargeProjects.html
• http://www.adaic.org/whyada/ada-vs-c/cppcv3.pdf
• http://weblog.raganwald.com/2006/03/fair-and-balanced-look-at-static-vs.html
• Article du Code Project suggérant d'introduire plus de dynamisme dans le langage : http://www.codeproject.com/KB/cpp/dynamic_cpp.aspx
• http://www.theregister.co.uk/2009/05/07/verity_stob_cplusplus/
• Yosef Kreinin n'aime vraiment pas C++ :
  • une « anti foire aux questions », avec pour rôle de critiques sévèrement le langage : http://yosefk.com/c++fqa/index.html
  • http://www.yosefk.com/blog/the-c-sucks-series-petrifying-functions.html
  • http://www.yosefk.com/blog/the-c-sucks-series-the-quest-for-the-entry-point.html
  • en 2014, Yosef Kreinin avoue peiner à tenir à jour cette « anti foire aux questions » mais détester toujours autant C++ : http://www.yosefk.com/blog/c11-fqa-anyone.html
• Critique des itérateurs, par Andrei Alexandrescu : http://www.boostcon.com/site-media/var/sphene/sphwiki/attachment/2009/05/08/iterators-must-go.pdf
• http://ridiculousfish.com/blog/archives/2009/06/22/i-didnt-order-that-so-why-is-it-on-my-bill-episode-1/
• Préférer Fortran à C++ : http://www.lahey.com/PRENTICE.HTM
• Pas de C++ dans le noyau de Linux (Linus Torvalds n'aime pas le langage) :
  • http://www.tux.org/lkml/#s15-3
  • http://kerneltrap.org/node/2067
  • http://lwn.net/Articles/249460/
  • http://article.gmane.org/gmane.comp.version-control.git/57918
  • comme l'indique Jeff Cogswell en 2015, toutefois, il n'est pas clair du tout que Linus Torvalds ait raison : http://news.dice.com/2015/03/10/linus-torvalds-was-sorta-wrong-about-c/
  • en 2009, John D. Cook se dit en désaccord avec Linus Torvalds sur ce sujet : https://www.johndcook.com/blog/2009/09/15/linus-torvalds-cpp/
  http://gigamonkeys.com/blog/2009/10/16/coders-c++.html
• http://eli.thegreenplace.net/2009/10/17/the-c-bashing-season-is-back/
• http://jafl.my.speedingbits.com/blog/2009/10/17/c/
• http://wordaligned.org/articles/next-permutation
• http://schneide.wordpress.com/2009/07/06/how-much-boost-does-a-c-newbie-need/
• Ceci est, bien entendu, humoristique : http://artlung.com/smorgasborg/Invention_of_Cplusplus.shtml
• Ceci aussi : http://www.teamten.com/lawrence/writings/dynamic_cast_std_integer_c.html
• Tiens, tiens : quel est le langage utilisé par les équipes en tête de liste?
  • http://csclub.uwaterloo.ca/contest/rankings.php?page=1
  • http://jpcameron.com/blog/?p=128
• http://eli.thegreenplace.net/2010/06/11/the-perils-of-unsigned-iteration-in-cc/
• http://blog.codeimproved.net/2010/07/whats-wrong-with-c/
• http://librelist.com/browser//mongrel2/2010/7/15/c-verses-c++/#770d94bcfc6ddf1d8510199996b607dd
• http://my.opera.com/Vorlath/blog/2010/07/17/c-does-it-suck
• http://apenwarr.ca/log/?m=201007#22
• http://www.fefe.de/c++/c%2b%2b-talk.pdf (j'ai beaucoup de réserves sur ce texte-là, mais enfin...)
• http://c0de517e.blogspot.com/2011/02/surviving-c.html
• http://miek.nl/downloads/2010/c++-talk.pdf (si je peux me permettre : je pourrais écrire quelque chose de semblable pour tout langage de programmation; c'est un peu faible)
• http://www.johndcook.com/blog/2011/06/14/why-do-c-folks-make-things-so-complicated/ (mais plus récemment http://www.johndcook.com/blog/2011/07/06/maybe-c-hasnt-jumped-the-shark-after-all/comment-page-1/)
• Les critiques positives sur C++ 11 commencent à circuler, par exemple :
  • http://cplusplus-soup.com/2011/07/05/what-youve-missed-with-c-2011-so-far/
  • http://www.voyce.com/index.php/2011/09/18/cpp-the-oldest-new-kid-on-the-block/
• Vivre le passage à un nouveau standard, une rélexion de Marc Mutz en 2011 : http://marcmutz.wordpress.com/2011/09/20/c98-support-costs-extra/
• En 2012, John Sonmez se dit d'avis que pour la plupart des applications, C++ est trop complexe pour ce qu'il apporte : http://simpleprogrammer.com/2012/12/01/why-c-is-not-back/
  • une réaction constructive de Herb Sutter, en 2012 : http://herbsutter.com/2012/12/03/perspective-why-c-is-not-back/
• Texte de 2012 par Jon Harrop, attaquant directement certaines propositions de Herb Sutter à propos du modèle mémoire de C++ 11 et de ses avantages : http://flyingfrogblog.blogspot.ca/2012/01/c-renaissance.html
• Critique de Bartosz Milewski en 2013, qui présente C++ comme le Edward Scissorhands de la programmation, capable de belles choses mais trop périlleux : http://bartoszmilewski.com/2013/09/19/edward-chands/
• Texte de Thomas Becker en 2013 sur ce qu'il qualifie de « culture de la complexité » : http://blog.greaterthanzero.com/post/58482859780/c-and-the-culture-of-complexity
• En 2013, Steve Donovan critique le design des templates sur plusieurs aspects : http://steved-imaginaryreal.blogspot.ca/2013/10/c-some-consequences-of-design-decision.html
• En 2014, Miguel de Icaza exprime sa vision quelque peu critique de certaines bibliothèques C++ : http://tirania.org/blog/archive/2014/Jan-04.html
• Texte de 2014 d'un auteur qui cherche un bon remplacement pour C++, qu'il estime être une chose du passé : http://c0de517e.blogspot.ca/2014/06/where-is-my-c-replacement.html
• Selon Igor Kalnitsky en 2014, le pire aspect de C++ est le legs du code C, qui fut longtemps l'un de ses plus grands avantages : http://kalnitsky.org/2014/10/25/c-legacy-is-evil/
• En 2012, Maurizio Tomasi explique ce que d'autres langages comme Ada et D lui ont appris sur C++ et qu'il n'apprécie pas : http://ziotom78.blogspot.it/2012/11/what-ada-and-d-taught-me-about-c.html
• Texte de 2014 défendant l'idée que le pire ennemi de C++ soit son passé : http://www.codergears.com/Blog/?p=867
• En 2010, Botond Ballo explique qu'il aime bien C++, personnellement, et donne ses raisons : https://botondballo.wordpress.com/2010/09/18/why-i-love-c-plus-plus/
• Texte de 2014 par Tony DaSilva, mettant l'accent sur le fait qu'on fasse erreur en prenant C++ comme un langage OO, fonctionnel ou générique, sa grande force étant qu'il embrasse toutes ces approches à la fois : http://bulldozer00.com/2014/05/30/fungenoop-programming/
• À propos de la complexité de C++ :
  • Le langage permet parfois certaines manoeuvres qui laissent perplexes, comme l'indique Nicolas Brailo en 2015 : https://monoinfinito.wordpress.com/2015/03/31/scope-ending-in-c/
  • Déclarer une variable peut cacher des pièges syntaxiques subtils, comme le rappelle Maxim Razin en 2015 : http://kukuruku.co/hub/cpp/a-non-obvious-feature-in-the-syntax-of-variable-declaration
  • La complexité est parfois la porte d'entrée des bogues, comme le rappelle ce texte de 2015 : http://kryptoslogic.blogspot.ca/2015/03/complexity-is-bugdoors-friend.html
  • Apprivoiser la complexité fait partie du plaisir de C++, selon ce texte de 2015 : https://schneide.wordpress.com/2015/03/30/managing-cs-complexity-or-learning-to-enjoy-c/
• Si vous utilisez encore Turbo C++, un produit du début des années 1990, il serait peut-être temps de vous mettre à jour... http://gettinggeek.com/stop-using-turbo-c-that-is-now-stupid/
• En 2010, texte dont l'auteur se dit d'avis que les abstractions que permet de réaliser C++ ne suffisent pas pour un projet d'envergure (je ne sais pas s'il a changé d'avis depuis C++ 11) : http://voodoo-slide.blogspot.ca/2010/01/amplifying-c.html
• Texte de 2013 où Dorin Lazăr explique qu'il a abandonné C++ : http://dorinlazar.ro/the-day-i-gave-up-on-cpp/
  • il fait un retour sur ce texte en 2016 avec http://dorinlazar.ro/why-c-sucks-2016-02-edition/
• Richard Mitton a des reproches à adresser au comité de standardisation :
  • reproches de 2015 : http://www.codersnotes.com/notes/cpp-rant-1/
  • reproches de 2016 : http://www.codersnotes.com/notes/cpp-rant-2/
• En 2016, Joseph Anderson explique pourquoi il n'a pas abandonné C++ : https://josephanders0n.github.io/2016/02/12/why-i-haven-t-given-up-on-c.html
• En 2015, Scott Meyers (oui, lui!) émet des critiques sévères envers C++ :
  • selon lui, à certains égards, il faudrait poser des gestes qui briseraient radicalement la compatibilité avec le passé : http://scottmeyers.blogspot.ca/2015/11/breaking-all-eggs-in-c.html
  • un plaidoyer pour de meilleurs outils : http://scottmeyers.blogspot.ca/2015/11/the-brick-wall-of-c-source-code.html
• Henrique F. Bucher se montre critique envers C++, en particulier son incarnation moderne :
  • texte de 2016 où il explique son désintérêt croissant envers le langage : http://www.vitorian.com/x1/archives/313
  • en 2016, il lance un défi, à savoir écrire en C++ moderne un programme qu'il ne pourrait écrire de manière à obtenir de meilleurs résultats en C : http://www.vitorian.com/x1/archives/301 (notez qu'il fait pencher la balance de son côté en contrôlant les paramètres du défi)
• Écrire du code obscur mais légal en C++, un texte très méchant de 2016 : https://dev.krzaq.cc/post/code-doodles-4-obfuscating-code-its-logical/
• En 2016, Henry Bucher (je pense) fait une critique étrange, à l'effet que C++ serait moins intéressant qu'il ne le semble car certains des outils de sa bibliothèque standard utilisent du code C sous la couverture : http://www.vitorian.com/x1/archives/393
• Dans ce texte de 2017, Evan Klitzke se porte à la défense de C++, le langage qui (malgré ses défauts) permet d'écrire du code extrêmement efficace : https://eklitzke.org/in-defense-of-c++
• En 2017, Oleksandr Kaleniuk estime que programmer en C++ est une forme de violence que l'on s'applique pour être fière / fier de soi : https://hackernoon.com/blood-sweat-and-c-294c8bb7836
• Texte de 2017 par Dendi Suhubdy pour qui, malgré quelques irritants, programmer avec C++ est la meilleure option pour qui souhaite du code extrêmement « performant » : http://suhubdy.com/blog/in-defence-of-c/
• Un exemple proposé par Eric Niebler (que plusieurs ont critiqué comme quelque peu mal avisé, étant inaccessible pour la pensée de la majorité... L'enfer est pavé de bonnes intentions!) a mené à quelques critiques bien senties :
  • l'exemple en question, publié en 2018 : http://ericniebler.com/2018/12/05/standard-ranges/
  • réaction (forte) d'Aras Pranckevičius, en 2018 : http://aras-p.info/blog/2018/12/28/Modern-C-Lamentations/
  • réaction de Sean Parent... à la réaction d'Aras Pranckevičius, en 2018 : https://sean-parent.stlab.cc/2018/12/30/cpp-ruminations.html
    • certains ont réagi à l'algorithme iota() et en particulier à son nom, ce qui a créé une tempête dans la tempête. Position de Sean Parent, toujous en 2018 : https://sean-parent.stlab.cc/2019/01/04/iota.html
  • contribution au débat de Ben Deane, un peu plus modéré : http://www.elbeno.com/blog/?p=1598
• En 2017, Robert O'Callahan exprimer les difficultés qu'il ressent à essayer d'écrire du code C++ robuste, pour mettre de l'avant que ce n'est pas une simple question de compétence : https://robert.ocallahan.org/2017/07/confession-of-cc-programmer.html
• En 2017, Eric S. Raymond explique pourquoi il ne veut plus toucher à C++ : http://esr.ibiblio.org/?p=7724
• En 2018, l'équipe de CppDepend montre, chiffres à l'appui, que C++ est plus pertinent que jamais : http://cppdepend.com/blog/?p=649
• Dans un autre article de 2018, l'équipe de CppDepend discute de la différence entre « supporter la programmation de bas niveau » et « être trop compliqué » : http://cppdepend.com/blog/?p=766
• Critique de Jonathan Blow, qui explique ce qu'il n'aime pas de C++ et pourquoi il développe son propre langage, Jai : https://www-gamesindustry-biz.cdn.ampproject.org/v/s/www.gamesindustry.biz/amp/2018-07-02-jonathan-blow-c-is-a-weird-mess
• En 2018, Corentin Jabot offre une critique étoffée du modèle de compilation de C++ : https://cor3ntin.github.io/posts/translation_units/
• Dans ce texte de 2019, Alex Gaynor se dit d'avis qu'il est trop difficile d'écrire du code C++ robuste, même s'il est moderne : https://alexgaynor.net/2019/apr/21/modern-c++-wont-save-us/

Étrangetés techniques :

• En 2017, Simon Brand montre que l'opérateur :: de C++ a parfois un bien drôle de comportement : https://blog.tartanllama.xyz/silly-syntax/
• Glennan Carnie, dans ce texte de 2018, montre que la grammaire de C++ accepte parfois des parenthèses à des endroits discutables : https://blog.feabhas.com/2018/02/may-not-meet-developer-expectations-77/
• Présentation de Simon Brand en 2018, qui met en relief quelques étrangetés du langage : https://docs.google.com/presentation/d/1V98O1F7aFqqCdenDQsUI3ZlQVHUwZIvkmB2HyPAJH4Y/edit#slide=id.g3482464683_0_154
• Texte d'Arthur O'Dwyer en 2018 décrivant quelques « impossibilités » avec C++ : https://quuxplusone.github.io/blog/2018/06/12/perennial-impossibilities/
• En 2018, Arthur O'Dwyer souligne que la programmation générique par contrainte sur des références peut surprendre... https://quuxplusone.github.io/blog/2018/09/09/constrained-forwarding-references/
• Survol de manières étranges de dire "Hello" en C++, une courte présentation de Olve Maudal en 2018 : https://speakerdeck.com/olvemaudal/42-silly-ways-to-say-hello-in-modern-c-plus-plus-sep-2018
• Durant CppCon 2018, Richard Smith a lancé un concours. Pour le remporter, il fallait livrer un extrait de programme C++ valide mais « intéressant » (au sens de surprenant, horrible, décontenançant, etc.) et suffisamment concis pour être logé dans un tweet : https://zygoloid.github.io/cppcontest2018.html (il y a des horreurs épouvantables dans ça, la plupart des vraiment vilaines venant de membres du WG21)
• Série d'étrangetés mises en lumière par Bartlomiej Filipek en 2019 : https://www.bfilipek.com/2019/03/darker-cpp.html

Dialectes

C++ n'est pas un langage qui encourage la segmentation en dialectes, mais il en existe malgré tout quelques-uns.

• Le Embedded C++, destiné aux systèmes embarqués :
  • http://www.caravan.net/ec2plus/
  • http://www.caravan.net/ec2plus/language.html
  • http://www.ghs.com/wp/ec++article.html
• Le dialecte C++/CLI, destiné à la plateforme .NET :
  • textes d'Herb Sutter, qui en a été l'architecte principal :
    • http://www.gotw.ca/publications/standard_c++_meets_managed_c++.htm
    • http://www.gotw.ca/publications/C++CLIRationale.pdf
  • critique de Danny Kalev, en 2006 (un peu sévère à mon avis, mais faut rappeler à quel point le prédécesseur de de dialecte était médiocre) :
    • http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=274
    • http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=275
  • http://blogs.msdn.com/b/vcblog/archive/2006/08/02/686894.aspx
  • la bibliothèque STL/CLR : http://msdn.microsoft.com/fr-fr/library/bb385954.aspx
  • le problème du support du concept de constance dans une plateforme comme celle de .NET : http://blogs.msdn.com/b/slippman/archive/2004/01/22/61712.aspx
  • http://msdn.microsoft.com/fr-fr/library/bb738066.aspx
  • le support d'IntelliSense pour C++/CLI dans Visual Studio 2010 : http://blogs.msdn.com/b/vcblog/archive/2011/03/03/10136696.aspx
  • on semble, chez Microsoft, se diriger vers WinC++, peu importe ce que ça signifie : http://www.zdnet.com/blog/microsoft/what-is-winc-and-how-does-it-figure-in-microsofts-bid-to-make-tools-a-2-billion-business/9359
  • texte du Code Project, par Nicolas Dorier en 2012, sur quelques pièges de la programmation avec C++/CLI : http://www.codeproject.com/Articles/442784/Best-gotchas-of-Cplusplus-CLI
  • introduction à C++/CLI, textes du Code Project...
    • en 2015 : http://www.codeproject.com/Articles/721062/Cplusplus-CLI-for-Beginners
    • en 2017, par Jon McKee : https://www.codeproject.com/Articles/1139538/Cplusplus-CLI-Under-the-Hood
• Le dialecte C++/CX, syntaxiquement semblable à C++/CLI mais qui ne dépend pas du CLR de .NET et qui ne génère que du code natif. Un outil important dans Windows 8 :
  • http://blogs.msdn.com/b/vcblog/archive/2011/10/20/10228473.aspx
  • C++/CX et les classes partielles : http://mariusbancila.ro/blog/2011/10/13/cpp-winrt-and-partial-classes/
  • http://www.i-programmer.info/programming/winrt/3172-building-and-using-winrt-components.html
  • intégrer C++/CX et XAML, par Andy Rich en 2012 : http://blogs.msdn.com/b/vcblog/archive/2012/08/24/10343401.aspx
  • une série de textes d'introduction à C++/CX :
    • texte de James McNellis en 2012 : http://blogs.msdn.com/b/vcblog/archive/2012/08/29/cxxcxpart00anintroduction.aspx
    • autre texte de 2012 (pas signé, cette fois), qui met en relief que le code généré par la compilation de code C++/ CX est en fait du code C++ pour la plateforme COM : http://blogs.msdn.com/b/vcblog/archive/2012/09/05/cxxcxpart01asimpleclass.aspx
    • toujours en 2012, le symbole ^ pour gérer les références aux Windows Runtime Objects : http://blogs.msdn.com/b/vcblog/archive/2012/09/17/cxxcxpart02typesthatwearhats.aspx
    • texte de James McNellis en 2012 : http://blogs.msdn.com/b/vcblog/archive/2012/10/05/cxxcxpart03underconstruction.aspx
    • les méthodes statiques, par James McNellis en 2012 : http://blogs.msdn.com/b/vcblog/archive/2012/10/19/cxxcxpart04staticmemberfunctions.aspx
  • tour d'horizon de C++/CX, par Thomas Petchel en 2013 : http://msdn.microsoft.com/en-us/magazine/dn166929.aspx
  • permuter de manière atomique deux pointeurs ^, un texte de 2017 par Raymond Chen : https://blogs.msdn.microsoft.com/oldnewthing/20170210-00/?p=95405
• De manière plus générale, C++ sous Microsoft Windows :
  • http://msdn.microsoft.com/en-US/visualc/hh302879.aspx
  • Utiliser C++ et COM avec WinRT, par Christophe Pichaud en 2014 : http://www.drdobbs.com/windows/using-c-and-com-with-winrt/240168150?_mc=sm_drd
• Utiliser C++ comme langage de script dans un jeu, texte de Stefan Reinalter en 2014 : http://molecularmusings.wordpress.com/2014/05/10/using-runtime-compiled-c-code-as-a-scripting-language-under-the-hood/

Standardisation

Standardisation (voir aussi C++ 11, C++ 14 et C++ 17)  :

• L'état de la situation, tenu à jour de manière épisodique : https://isocpp.org/std/status
• Obtenir une version du standard ISO de C++ : http://herbsutter.com/2010/03/03/where-can-you-get-the-iso-c-standard-and-what-does-open-standard-mean/
• Pourquoi le standard ISO de C++ est-il mis à jour selon un cycle de trois ans? En 2019, Herb Sutter explique : https://herbsutter.com/2019/07/13/draft-faq-why-does-the-c-standard-ship-every-three-years/
• Soumettre une proposition pour fins de standardisation :
  • comment faire : https://isocpp.org/std/submit-a-proposal
  • la personne à qui l'envoyer est celle qui dirige LWG. Son adresse courriel est disponible sur : http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html
  • en format HTML : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3325.html
  • les sources utilisées pour générer le standard lui-même (si vous êtes intéressé(e) au format L^AT_EX) : https://github.com/cplusplus/draft
• Comment référencer le standard, un texte de 2019 par Bartlomiej Filipek : https://www.bfilipek.com/2019/05/ref-cpp-standard.html
• Participer au comité de standardisation esrt une activité bénévole (oui, nous payons pour travailler... Sans commentaires). Il est toutefois possible (mais pas facile) de demander une aide financière. En 2018, JeanHeyd Meneide écrit sur son aventure pour obtenir un tel soutien : https://thephd.github.io/getting-there-standardization-in-2019
• Le standard ISO de 1998, version presque finale  : http://www-d0.fnal.gov/~dladams/cxx_standard.pdf
• Le standard ISO de C++ 11, version presque finale : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.pdf
• Version la plus à jour (à ma connaissance) du projet de standard pour C++ 17 : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4640.pdf (la version officielle, mays payante, est disponible sur https://www.iso.org/standard/68564.html)
• Version de travail la plus à jour pour le standard : http://wg21.link/draft

• La constitution du comité de standardisation : http://isocpp.org/std/the-committee
• Entrevue avec Bjarne Stroustrup, en 2012, portant en particulier sur la question de la standardisation du langage : http://www.theregister.co.uk/2012/12/13/stroustrup_on_c_plus_plus/
• En 2018, Bjarne Stroustrup rappelle l'importance que garder une direction claire dans le processus de standardisation : https://www.theregister.co.uk/2018/06/18/bjarne_stroustrup_c_plus_plus/
• La proposition originale de standardisation du langage C++, faite par Dmitry Lenkov en 1989 : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1989/X3_89-738R%20Programming%20Language%20C++%20Proposal.pdf
• Le principe du Zero Overhead, ou « on ne paie pas pour ce qu'on n'utilise pas » :
  • selon Daniel Gutson, Angel Bustamante, Pablo Oliva, Marcos Diaz en 2014, ce principe a ses limites : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4049.pdf
• Réflexion de Guy Davidson en 2018 sur ce qui devrait – ou ne devrait pas – être intégré à la bibliothèque standard : https://hatcat.com/?p=16
  • réplique de Corentin Jabot en 2018 : https://hackernoon.com/a-cake-for-your-cherry-what-should-go-in-the-c-standard-library-804fcecccef8
  • position de Titus Winters, en 2018 : https://abseil.io/blog/20180227-what-should-go-stdlib