Générateur de structures C++ à partir de JSON
Générez des définitions de structures C++ à partir d'objets JSON. Le résultat inclut des structures dotées des macros de fonction `from_json` et `to_json` de la bibliothèque nlohmann/json, assurant la correspondance entre les types JSON et les types C++ appropriés (tels que `std::string`, `int64_t`, `double`, `bool` et `std::vector`).
Génère des structures C++ avec des liaisons de macros nlohmann/json.
Associe les types JSON aux types standard C++ (std::string, int64_t, double, bool, std::vector<T>).
Génère des macros NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE pour une liaison JSON propre.
Crée des définitions de structures imbriquées pour des objets JSON imbriqués.
Compatible avec la bibliothèque populaire nlohmann/json (fichier d'en-tête unique).
Mode d'emploi
Collez un objet JSON dans le champ de saisie.
Le générateur produit des définitions de structures C++ avec des macros nlohmann/json.
Incluez nlohmann/json.hpp dans votre projet
Utilisez nlohmann::json::parse et get<T>() pour désérialiser vos structures.
Applications C++
- Analyser les réponses d'API REST dans des clients C++
- Lire des fichiers de configuration JSON dans des services C++
- Désérialiser des messages JSON dans des systèmes embarqués
Développement de jeux
- Analyser les fichiers JSON de configuration du jeu
- Charger les données de niveau à partir de ressources JSON
- Désérialiser les charges utiles réseau sur les serveurs de jeu
Environnements C++
- Projets CMake
- Moteurs de jeu
- Services Linux embarqué
- Backends haute performance
Pour les champs JSON facultatifs, utilisez std::optional<T> (C++17) combiné à une fonction from_json personnalisée plutôt qu'à la macro.
Incluez nlohmann/json en tant que dépendance sous forme de fichier d'en-tête unique ou via CMake FetchContent ; c'est l'une des bibliothèques C++ les plus populaires.
Les nombres JSON sans décimale sont convertis en `int64_t` pour une plage de valeurs maximale ; utilisez manuellement `int32_t` si vous avez la certitude que les valeurs tiennent dans ce format et que la mémoire est limitée.
Utilisez std::optional<T> (C++17) pour les champs JSON pouvant être nuls ou absents, afin d'éviter un comportement indéfini lorsque la clé est manquante.
Privilégiez int64_t plutôt que int pour les champs entiers JSON afin de gérer en toute sécurité les identifiants de grande taille et les horodatages.
Ajoutez nlohmann/json via CMake FetchContent ou vcpkg plutôt que de copier manuellement le fichier d'en-tête, afin de maintenir une gestion propre de vos dépendances.
Foire aux questions
Trouvez des réponses aux questions fréquentes sur nos outils et services.
Comprendre JSON vers structure C++
Le C++ est largement utilisé dans des domaines où la performance, la faible latence et l'accès direct au matériel sont critiques : moteurs de jeu, systèmes temps réel, trading haute fréquence, robotique, services Linux embarqués et calcul scientifique. Ces systèmes communiquent de plus en plus avec des API REST, des microservices et des systèmes de configuration utilisant le format JSON. Alors que le C++ était historiquement associé aux protocoles binaires et aux formats de sérialisation personnalisés, l'écosystème C++ moderne a adopté le JSON grâce à la bibliothèque nlohmann/json, devenue l'un des projets C++ les plus populaires sur GitHub. Son modèle de distribution sous forme d'un fichier d'en-tête unique et son API intuitive en font la solution privilégiée pour la gestion du JSON dans les projets C++ ne nécessitant pas de contraintes de performance strictes pour l'analyse (parsing) de ce format.
La bibliothèque nlohmann/json propose plusieurs méthodes pour désérialiser du JSON en types C++. Pour des données structurées simples, la macro NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE constitue l'approche la plus pratique : elle prend en entrée le nom d'un type `struct` ainsi qu'une liste de noms de champs, puis génère automatiquement les fonctions `from_json` et `to_json` qui associent les clés JSON aux champs de la structure par leur nom. Cette approche basée sur des macros ne nécessite aucune modification de la définition de la structure elle-même ; elle est donc non intrusive et compatible avec des structures définies dans des fichiers d'en-tête partagés avec du code n'utilisant pas nlohmann/json. La liaison générée fait l'objet d'une vérification de type à la compilation grâce à la spécialisation de modèles (templates), ce qui permet de détecter les incompatibilités de type entre le JSON et la structure C++ lors de la phase de construction plutôt qu'à l'exécution.
Le système de typage du C++ nécessite une correspondance rigoureuse entre les valeurs JSON à typage dynamique et les champs C++ à typage statique. Les chaînes JSON deviennent des `std::string`. Les entiers JSON deviennent des `int64_t` afin de garantir une portabilité maximale de la plage de valeurs entre les plateformes 32 bits et 64 bits, évitant ainsi les risques de dépassement de capacité associés aux types `int` ou `int32_t` lors de la manipulation d'identifiants d'API ou d'horodatages élevés. Les nombres à virgule flottante JSON deviennent des `double`. Les booléens JSON deviennent des `bool`. Les tableaux JSON deviennent des `std::vector<T>` avec le type d'élément approprié. La valeur `null` de JSON constitue le cas le plus complexe : le C++ ne disposant pas de sémantique de référence nulle native pour les types valeur, les champs JSON pouvant être nuls nécessitent l'utilisation de `std::optional<T>` (disponible depuis C++17) pour représenter correctement la distinction entre présence et absence de valeur.
Ce générateur de structures C++ à partir de JSON produit des définitions de structures incluant les liaisons de la macro `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`, des types de champs C++ standard respectant les conventions de correspondance susmentionnées, ainsi que des définitions de structures imbriquées pour les objets JSON imbriqués. Le code généré est compatible avec les normes C++ modernes (C++11 et versions ultérieures pour les fonctionnalités de base, C++17 pour `std::optional`). Il suffit d'ajouter le fichier d'en-tête unique `nlohmann/json` ou de l'inclure via la commande `FetchContent` de CMake pour compiler et exécuter le code généré. Pour les développeurs C++ concevant des clients API, des chargeurs de données de jeu, des analyseurs de configuration ou des désérialiseurs de messages réseau, ce générateur offre un gain de temps considérable sur le travail de modélisation des données nécessaire à toute intégration JSON.