real time cpp
1.0.0
Il s'agit du code compagnon du livre CM Kormanyos, Real-Time C++ : Efficient Object-Oriented and Template Microcontroller Programming, Quatrième édition (Springer, Heidelberg, 2021) ISBN 9783662629956.
Ce référentiel comporte plusieurs parties principales.
ref_app située dans ref_app. Cela inclut également les critères de référence. Les compilateurs croisés GNU/GCC et divers outils supplémentaires fonctionnant sur Win* , éventuellement nécessaires pour certaines versions comme décrit ci-dessous, peuvent être trouvés dans le référentiel ckormanyos/real-time-cpp-toolchains associé.
L'application de référence démarre avec un petit code de démarrage et initialise ensuite une couche d'abstraction de microcontrôleur mince (MCAL). Le contrôle est ensuite transmis à un simple planificateur multitâche qui gère l'application LED, appelle une tâche de référence cyclique et assure le service de surveillance.
L'application LED fait basculer une LED utilisateur avec une fréquence de
L'application de référence est compatible avec C++ 14, 17, 20, 23 et au-delà.
Le logiciel d'application est implémenté une seule fois et utilisé uniformément sur chaque cible prise en charge dans ref_app. Les différences entre les cibles individuelles apparaissent uniquement dans les couches logicielles inférieures concernant les détails de démarrage/MCAL spécifiques à la puce et à la carte.
De cette manière, le projet présente un haut niveau de portabilité.
L'application de référence prend en charge les cibles suivantes :
| Nom de la cible (tel qu'utilisé dans la commande build) | Description de la cible | *(planche à pain) |
|---|---|---|
avr | MICROCHIP(R) [ancien ATMEL(R)] AVR(R) ATmega328P | X |
atmega2560 | MICROCHIP(R) [ancien ATMEL(R)] AVR(R) ATmega2560 | |
atmega4809 | MICROCHIP(R) [ancien ATMEL(R)] AVR(R) ATmegax4809 | X |
am335x | BeagleBone avec Texas Instruments(R) AM335x ARM(R) A8 | |
bcm2835_raspi_b | RaspberryPi(R) zéro avec ARM1176-JZFS(TM) | |
Debug / Release | PC sous Win* via le compilateur MSVC x64 Debug / Release | |
host | PC/Station de travail sur Win* / mingw64 / *nix via le compilateur hôte | |
lpc11c24 | Carte NXP(R) OM13093 LPC11C24 ARM(R) Cortex(R)-M0+ | |
nxp_imxrt1062 | Carte Teensy 4.0 / NXP(R) iMXRT1062 ARM(R) Cortex(R)-M7 | X |
riscvfe310 | SoC SiFive RISC-V FE310 | |
rl78 | Renesas(MD) RL78/G13 | |
rpi_pico_rp2040 | RaspberryPi(R) Pico RP2040 avec double ARM(R) Cortex(R)-M0+ | X |
rpi_pico2_rp2350 | RaspberryPi(R) Pico2 RP2350 avec double ARM(R) Cortex(R)-M33 | X |
rx63n | Renesas(MD) RX630/RX631 | |
stm32f100 | STMicroelectronics(R) STM32F100 ARM(R) Cortex(R)-M3 | X |
stm32f407 | STMicroelectronics(R) STM32F407 ARM(R) Cortex(R)-M4F | |
stm32f429 | STMicroelectronics(R) STM32F429 ARM(R) Cortex(R)-M4F | |
stm32f446 | STMicroelectronics(R) STM32F446 ARM(R) Cortex(R)-M4F | |
stm32h7a3 | STMicroelectronics(R) STM32H7A3 ARM(R) Cortex(R)-M7 | |
stm32l100c | STMicroelectronics(R) STM32L100 ARM(R) Cortex(R)-M3 | X |
stm32l152 | STMicroelectronics(R) STM32L152 ARM(R) Cortex(R)-M3 | |
stm32l432 | STMicroelectronics(R) STM32L432 ARM(R) Cortex(R)-M4F | X |
v850es_fx2 | Renesas(R) Électronique V850es/Fx2 upd703231 | |
wch_ch32v307 | Carte RISC-V WCH CH32v307 | |
wch_ch32v307_llvm | Carte WCH CH32v307 RISC-V (mais utilisant une chaîne d'outils LLVM) | |
x86_64-w64-mingw32 | PC sous Win* / mingw64 via le compilateur GNU/GCC x86_x64 | |
xtensa32 | Expressif (XTENSA) NodeMCU ESP32 | X |
Dans ce tableau, *(breadboard) signifie que la carte (ou certaines versions de celle-ci) peut être facilement utilisée avec une maquette commune. Cela peut éventuellement nécessiter une soudure/montage manuel très simple des broches d'embase.
Il est plus simple de démarrer avec l'application de référence en utilisant l'une des cartes prises en charge, comme avr (ARDUINO) ou bcm2835_raspi_b (RaspberryPi ZERO) ou am335x (BeagleBoneBlack), etc. L'application de référence se trouve dans le répertoire ref_app et ses sous-répertoires .
L'application de référence utilise le développement croisé et les systèmes de build sont pris en charge sur :
*nix make tools en combinaison avec Bash/GNUmake (script bash) sur LINUX/MacOS,*nix sur Win* en combinaison avec un script batch ou Microsoft(R) Visual Studio(R) via un Makefile externe ,Win* , Une fois la construction terminée, les artefacts résultants, notamment les fichiers HEX (tels que ref_app.hex ), les fichiers de carte, les rapports de taille, etc., sont disponibles dans le répertoire bin .
Pour démarrer avec l'application de référence sur *nix
target avr ) que vous souhaitez créer.build.sh avec la commande : ./target/build/build.sh avr rebuild .avr rebuild qui reconstruisent ensuite l'intégralité de la solution pour target avr .*nix , exécutez sudo apt install gcc-avr avr-libc .*nix pour target avr Nous allons maintenant illustrer comment créer l'application de référence sur un shell de commande dans *nix pour target avr . Ce système cible comprend essentiellement n'importe quelle carte compatible ARDUINO(R). Il s'agit également de la compatibilité des cartes réellement utilisée avec les cartes faites maison dans le livre.
Installez gcc-avr si nécessaire.
sudo apt install gcc-avr avr-libcClonez ou récupérez le référentiel ckormanyos/real-time-cpp. Construisez ensuite avec :
cd real-time-cpp
cd ref_app
./target/build/build.sh avr rebuild*nix pour target stm32f446 Nous allons maintenant illustrer comment créer l’application de référence sur un shell de commande dans *nix pour une cible ARM(R). Considérons, par exemple, la target stm32f446 . La carte NUCLEO-F446RE de STMicroelectronics(R) peut facilement être utilisée à cet effet.
Installez gcc-arm-none-eabi si nécessaire.
sudo apt install gcc-arm-none-eabiClonez ou récupérez le référentiel ckormanyos/real-time-cpp. Construisez ensuite avec :
cd real-time-cpp
cd ref_app
./target/build/build.sh stm32f446 rebuildtarget stm32f446 Nous allons maintenant illustrer comment créer l’application de référence dans un shell de commande sous MacOS pour une cible ARM(R). Considérons, par exemple, la target stm32f446 . La carte NUCLEO-F446RE de STMicroelectronics(R) peut être utilisée à cet effet.
Clonez ou récupérez le référentiel ckormanyos/real-time-cpp.
La version par défaut 3.81 de GNUmake sur MacOS peut (désormais) être utilisée. Les fichiers make utilisés dans ce référentiel ont été rendus compatibles avec celui-ci. Pour des informations générales, voir également le numéro 273.
Construisez la cible avec un appel manuel direct à make .
cd real-time-cpp
cd ref_app
make -f target/app/make/app_make.gmk rebuild TGT=stm32f446Si la chaîne d'outils est nécessaire, elle doit être installée ou récupérée avant de créer la cible de l'application de référence.
Vous pouvez obtenir via wget (ou éventuellement installer) la chaîne d'outils gcc-arm-none-eabi si nécessaire. Dans ce cas, j'ai trouvé pratique d'utiliser un gcc-arm-none-eabi moderne pour MacOS qui peut être trouvé sur Arm GNU Toolchain Downloads.
La chaîne d'outils arm-non-eabi peut être récupérée via wget et utilisée avec succès localement dans le shell. Si vous le souhaitez, suivez la procédure étape par étape ci-dessous.
Étape 1 : Créez un répertoire local (tel que macos-gnu-arm-toolchain ) et insérez-y cd .
cd real-time-cpp
mkdir -p macos-gnu-arm-toolchain
cd macos-gnu-arm-toolchain Étape 2 : Récupérez l'archive tar de la chaîne d'outils avec wget , décompressez-la et ajoutez le répertoire bin du compilateur au chemin de l'exécutable du shell.
wget --no-check-certificate https://developer.arm.com/-/media/Files/downloads/gnu/12.2.rel1/binrel/arm-gnu-toolchain-12.2.rel1-darwin-x86_64-arm-none-eabi.tar.xz
tar -xvf arm-gnu-toolchain-12.2.rel1-darwin-x86_64-arm-none-eabi.tar.xz
PATH= $( pwd ) /arm-gnu-toolchain-12.2.rel1-darwin-x86_64-arm-none-eabi/bin: $PATH Étape 3 : Éventuellement, echo au PATH pour une vérification rapide du chemin. Il peut également être utile d'interroger la version de arm-non-eabi-g++ . Cela devrait vérifier que la chaîne d'outils est correctement ajoutée au PATH local de ce shell.
echo $PATH
arm-none-eabi-g++ -v Maintenant, utilisez simplement les commandes pour construire la cible avec un appel direct à make (ce qui est le même que celui indiqué ci-dessus pour le cas *nix ).
cd real-time-cpp
cd ref_app
make -f target/app/make/app_make.gmk rebuild TGT=stm32f446 Pour débuter avec l'application de référence sur Win*
Win* , comme décrit en détail quelques paragraphes ci-dessous.ref_app.sln dans le répertoire ref_app. La version ref_app dans Microsoft(R) VisualStudio(R) fait un usage intensif du développement croisé à l'aide d'un espace de travail de projet de type External Makefile . GNUmake est invoqué via un fichier batch dans le processus de construction. Il s'exécute ensuite en combinaison avec plusieurs Makefiles.
Pour créer une cible ref_app autre que Debug ou Release for Win32, un compilateur croisé (compilateur croisé GNU/GCC) est requis. Voir le texte ci-dessous pour plus de détails.
Les compilateurs croisés GNU/GCC fonctionnant sous Win* destinés à l'application de référence sur VisualStudio(R) peuvent être trouvés dans le référentiel de chaînes d'outils , ckormanyos/real-time-cpp-toolchains. Le référentiel des chaînes d'outils contient des instructions détaillées sur l'installation, le déplacement et l'utilisation de ces compilateurs GNU/GCC portés.
Note sur GNUmake pour Win* : Un GNUmake capable d'être utilisé sur Win* peut être trouvé dans le dépôt ckormanyos/make-4.2.1-msvc-build. Si vous le souhaitez, clonez ou récupérez le code de ce référentiel. Construisez make-4.2.1 dans sa configuration Release x64 avec MSVC (c'est-à-dire VC 14.2 ou version ultérieure, Community Edition est OK).
Cross-Environment CMake peut créer l'application de référence. À cette fin, des fichiers CMake ont également été créés pour chaque cible prise en charge.
Pensez, par exemple, à créer l'application de référence pour la cible avr avec CMake. Le modèle est présenté ci-dessous.
cd real-time-cpp
mkdir build
cd build
cmake ../ref_app -DTRIPLE=avr -DTARGET=avr -DCMAKE_TOOLCHAIN_FILE=../ref_app/cmake/gcc-toolchain.cmake
make -j ref_appNous allons maintenant considérer, par exemple, construire l'application de référence pour l'une des cibles ARM(R) supportées avec CMake. Le modèle est présenté ci-dessous. Dans ce cas, nous devons identifier les options de création suivantes :
-DTRIPLE=avr -DTARGET=avr Basculez ces options vers celles destinées à la cible basée sur stm32f446 ARM(R) en cours de construction.
-DTRIPLE=arm-none-eabi -DTARGET=stm32f446 Clarifions les commandes dans leur intégralité afin d'exécuter une version CMake pour stm32f446 (c'est-à-dire ST Microelectronics(R) STM32F446 ARM(R) avec Cortex(R)-M4F).
cd real-time-cpp
mkdir build
cd build
cmake ../ref_app -DTRIPLE=arm-none-eabi -DTARGET=stm32f446 -DCMAKE_TOOLCHAIN_FILE=../ref_app/cmake/gcc-toolchain.cmake
make -j ref_app Lors de la construction avec CMake pour d'autres cibles, suivez le modèle standard *nix pour construire. La construction avec CMake pour x86_64-w64-mingw32 ou host de MSYS, Cygwin ou tout autre shell ou console similaire de type *nix devrait également fonctionner.
La séquence de commandes suivante sera construite pour l' host natif sur un shell ou une console de type *nix .
cd real-time-cpp
mkdir build
cd build
cmake ../ref_app -DTARGET=host -DCMAKE_TOOLCHAIN_FILE=../ref_app/cmake/gcc-toolchain.cmake
make -j ref_app Il existe également une solution d'espace de travail pour ATMEL(R) AtmelStudio(R) 7. Elle s'appelle ref_app.atsln et se trouve également dans le répertoire ref_app. Il existe des projets ATMEL Studio pour l'application de référence ainsi que pour chacun des exemples. Les projets ATMEL Studio dans ce référentiel prennent uniquement en charge la cible AVR.
Si vous décidez d'utiliser ATMEL Studio, vous n'avez pas besoin d'utiliser ou d'inclure des bibliothèques supplémentaires pour ces projets (autres que celles qui sont habituellement installées lors de l'installation standard d'ATMEL Studio).
Les détails de la cible, y compris le code de démarrage et les fichiers de définition de l'éditeur de liens, peuvent être trouvés dans le répertoire ref_app/target et ses sous-répertoires. Il existe des sous-répertoires individuels pour chaque système de microcontrôleur cible pris en charge.
La configuration MICROCHIP(R) [ancien ATMEL(R)] AVR(R) appelée target avr fonctionne sur une carte classique compatible ARDUINO(R). Le programme bascule la LED jaune sur portb.5 .
La configuration MICROCHIP(R) [ancien ATMEL(R)] ATmega4809 appelée target atmega4809 fonctionne sur un ARDUINO(R) CHAQUE carte compatible cadencée avec le résonateur interne à porte.2 (c'est-à-dire D5 ).
L'implémentation NodeMCU ESP32 d'Espressif (XTENSA) utilise un sous-ensemble du SDK Espressif pour exécuter l'application de référence avec une seule tâche de système d'exploitation exclusivement sur 1 de ses cœurs.
La configuration ARM(R) Cortex(R)-M0+ de la carte NXP(R) OM13093 LPC11C24 appelée « cible lpc11c24 » fait basculer la LED sur port0.8 .
La configuration ARM(R) Cortex(R)-M3 (appelée target stm32f100 ) s'exécute sur la carte STM32VL-DISCOVERY disponible dans le commerce auprès de ST Microelectronics(R). Le programme bascule la LED bleue sur portc.8 .
La deuxième configuration ARM(R) Cortex(R)-M3 (appelée target stm32l100c ) fonctionne sur la carte STM32L100-DISCOVERY disponible dans le commerce auprès de ST Microelectronics(R). Le programme bascule la LED bleue sur portc.8 .
La troisième configuration ARM(R) Cortex(R)-M3 (appelée target stm32l152 ) fonctionne sur la carte STM32L152C-DISCOVERY disponible dans le commerce auprès de ST Microelectronics(R). Le programme bascule la LED bleue sur portb.6 .
La première configuration ARM(R) Cortex(R)-M4F (appelée target stm32f407 ) s'exécute sur la carte STM32F4-DISCOVERY disponible dans le commerce auprès de ST Microelectronics(R). Le programme bascule la LED bleue sur portd.15 .
Une autre configuration ARM(R) Cortex(R)-M4F (appelée target stm32f446 ) s'exécute sur la carte STM32F446-NUCLEO-64 disponible dans le commerce auprès de ST Microelectronics(R). Le programme bascule la LED verte sur porta.5 . Un fichier de débogage Ozone est fourni pour ce système pour les personnes intéressées.
La première configuration ARM(R) Cortex(R)-M7 (appelée target stm32h7a3 ) fonctionne sur la carte STM32H7A3-NUCLEO-144 disponible dans le commerce auprès de ST Microelectronics(R). Le programme bascule la LED verte sur portb.0 .
La configuration ARM(R) A8 (appelée target am335x ) fonctionne sur la carte BeagleBone (édition noire). Pour l'édition blanche, la fréquence du processeur doit être réduite de *nix sur la carte. Notre programme est conçu pour démarrer le BeagleBone à partir d'un fichier binaire brut appelé MLO stocké sur une microcarte SDHC FAT32. Le fichier binaire comprend un en-tête de démarrage spécial composé de deux entiers de 32 bits. Le programme est chargé de la carte SD dans la mémoire RAM puis exécuté. Lors de la mise sous tension du BeagleBone black, il faut appuyer sur le bouton de démarrage (S2) lors de la mise sous tension de la carte. Le programme active la LED du premier utilisateur (LED1 sur port1.21 ).
La configuration ARM(R) 1176-JZF-S (appelée target bcm2835_raspi_b ) s'exécute sur le contrôleur monocœur RaspberryPi(R) Zero (PiZero). Ce projet crée un programme nu pour le PiZero. Ce programme fonctionne indépendamment de tout type de distribution *nix sur la carte. Notre programme est conçu pour démarrer le PiZero à partir d'un fichier binaire brut. Le fichier binaire brut s'appelle kernel.img et il est stocké sur une microcarte SDHC FAT32. Le programme objcopy peut être utilisé pour extraire le binaire brut d'un fichier ELF en utilisant les indicateurs de sortie -O binary . Le fichier kernel.img est stocké sur la carte SD avec trois autres fichiers : bootcode.bin, start.elf et (facultatif) config.txt, tous décrits sur Internet. Un ensemble complet de contenus de démarrage PiZero pour une carte SD exécutant l'application de référence bare metal est inclus dans ce dépôt. Le programme fait basculer la LED d'état GPIO à l'index GPIO 0x47 .
La configuration cible rpi_pico_rp2040 utilise le RaspberryPi(R) Pico RP2040 avec un ARM(R) Cortex(R)-M0+ double cœur cadencé à Blinky_Pico_dual_core_nosdk .
La configuration cible rpi_pico2_rp2350 utilise le RaspberryPi(R) Pico2 RP2350 avec un ARM(R) Cortex(R)-M33 double cœur cadencé à 2040 . De même, la startup dual-core a été pionnière grâce aux efforts révélés dans le dépôt modernisé Blinky_Pico2_dual_core_nosdk .
Target v850es_fx2 utilise un noyau Renesas(R) V850es/Fx2 classique. Le dérivé du microcontrôleur upd703231 sur un kit de démarrage F-Line Drive It est utilisé.
La cible riscvfe310 utilise le SoC SiFive RISC-V FE310 sur la carte Red Thing Plus disponible dans le commerce de Spark Fun. La LED bleue sur le port GPIO0.5 est allumée.
L'adaptation pour wch_ch32v307 fonctionne sur la carte WCH CH32v307. Il utilise le microcontrôleur RISC-V CH32v307 de Nanjing Qinheng Microelectronics Co., Ltd. La LED bleue 1 connectée manuellement au port GPIOC.0 via une connexion filaire fournit la bascule clignotante. L'adaptation similaire wch_ch32v307_llvm est essentiellement la même, sauf qu'elle utilise une chaîne d'outils LLVM RISC-V au lieu de GCC RISC-V.
Target nxp_imxrt1062 fonctionne sur la carte Teensy 4.0 de Spark Fun. La LED utilisateur orange est allumée.
Pour d'autres cartes compatibles, n'hésitez pas à me contacter directement ou à soumettre un problème demandant de l'aide pour le système cible souhaité.
Les benchmarks fournissent des moyens évolutifs et portables pour identifier les performances et la classe de performances du microcontrôleur. Pour plus d’informations, consultez les informations détaillées sur les pages des benchmarks.
Les projets de ce dépôt sont programmés sans système d'exploitation en mode nu et sans système d'exploitation en utilisant un code de démarrage auto-écrit. Aucune bibliothèque externe autre que le C++ natif et ses propres bibliothèques standard n'est utilisée.
Considérons, par exemple, le BeagleBone Black Edition (BBB, également connu sous le nom de target am335x ), qui est l'un des nombreux systèmes cibles populaires pris en charge dans ce référentiel. Les projets de cette carte démarrent à partir du fichier image binaire MLO sur la carte SD. Comme tous les autres projets de ce référentiel, les projets BBB effectuent leur propre initialisation statique et initialisation de puce (c'est-à-dire, dans ce cas particulier, l'initialisation de puce du processeur ARM(R) 8 AM335x). Les projets BBB, après l'initialisation, passent ensuite à main() qui initialise le MCAL am335x et démarre notre planificateur multitâche auto-écrit.
L'image ci-dessous représente le BeagleBone Black Edition nu en action. Dans ce mode de fonctionnement sans système d'exploitation, il n'y a pas de système d'exploitation *nix en cours d'exécution sur le BBB, pas de clavier, pas de souris, pas de moniteur, pas d'interface de débogage et pas d'émulateur.
Le microcontrôleur de la carte effectue de manière cyclique l'un des tests mentionnés ci-dessus. La première LED utilisateur est allumée sur port1.21 en fonctionnement multitâche et l'oscilloscope capture une mesure en temps réel du signal temporel de référence sur port1.15 d'E/S numérique 1.15, broche d'en-tête P8.15 du BBB.
Les badges d’état de build représentent l’état des builds et des tests nocturnes du CI.
avr-gcc moderne Le dépôt ckormanyos/avr-gcc-build construit des chaînes d'outils avr-gcc à jour pour x86_64-linux-gnu et x86_64-w64-mingw32 . Les scripts Shell et YAML créent avr-gcc directement à partir des sources sur les exécuteurs GHA. De plus, des versions occasionnelles de GitHub fournissent des chaînes d'outils avr-gcc prédéfinies pour x86_64-linux-gnu et x86_64-w64-mingw32 .
Ce référentiel est un excellent endroit pour apprendre à créer votre propre chaîne d'outils avr-gcc à partir des sources. Les scripts shell et YAML simples et bien décrits sont faciles à comprendre, à utiliser ou à adapter.
Comme mentionné ci-dessus, une portée beaucoup plus détaillée et plus large des chaînes d'outils intégrées est décrite dans ckormanyos/real-time-cpp-toolchains. Ceux-ci incluent la chaîne d'outils avr-gcc mentionnée ci-dessus ainsi que d'autres (certains difficiles à trouver ailleurs).
L'application de référence et les exemples (également les extraits de code) peuvent être construits avec les compilateurs GNU/GCC et GNUmake sur *nix . Les compilateurs croisés GNU/GCC et GNUmake sur *nix sont supposés être disponibles dans le chemin exécutable standard, par exemple après les pratiques standard d'installation.
Certains compilateurs croisés GNU/GCC portés pour Win* sont disponibles dans le référentiel de chaînes d'outils , real-time-cpp-toolchains. Ceux-ci peuvent être utilisés avec les configurations de solution de microcontrôleur dans l'application de référence lors du développement/construction dans Microsoft(R) VisualStudio(R). Divers autres outils GNU tels que GNUmake, SED, etc. ont été portés et peuvent y être trouvés. Ceux-ci sont utilisés dans les Makefiles lors de la création de projets multi-intégrés tels que ref_app sur Win* .
Dans l'application de référence sur Win* , les Makefiles utilisent un emplacement par défaut auto-défini pour les outils et chaînes d'outils GNU/GCC respectifs. L'emplacement par défaut de la chaîne d'outils sur Win* est ./ref_app/tools/Util/msys64/usr/local . Cet emplacement particulier de la chaîne d'outils est inspiré du système msys2 / mingw64 .
Les chaînes d'outils destinées aux versions croisées MSVC/GCC sur Win* doivent s'y trouver. Ces chaînes d'outils ne font pas partie de ce référentiel et il est nécessaire d'obtenir ces chaînes d'outils séparément lors de l'utilisation des versions Win* prises en charge lors de l'utilisation facultative de projets VisualStudio(R) avec CMD Batch.
Des instructions détaillées sur l'obtention et l'utilisation des chaînes d'outils pour les versions croisées MSVC/GCC sur Win* sont disponibles dans le référentiel real-time-cpp-toolchains. Ces instructions fournissent des conseils sur l'utilisation de ces chaînes d'outils lors de la sélection du projet Microsoft(R) VisualStudio(R) (via la méthode MSVC/ Win* habituelle décrite ci-dessus) pour créer l'application de référence.
Un port GNU/GCC (ou autre compilateur) avec un niveau élevé de connaissance et d'adhésion à C++ 14 (ou supérieur), tel que GCC 5 à 13 (un niveau supérieur étant généralement plus avantageux) ou MSVC 14.2 ou supérieur, est requis pour créer la référence. application (et les exemples et extraits de code).
Certains extraits de code démontrent des éléments de langage non seulement de C++14, mais également de C++17, 20, 23 et au-delà. Un compilateur prenant en charge C++17 ou même C++20, 23 (comme GCC 13, clang 15, MSVC 14.3 ou supérieur) peut donc être bénéfique pour réussir avec tous les extraits de code.
<chrono> , <ratio> et certains en-têtes de traits internes sont sous licence GNU General Public License version 3 ou supérieure.
