La bibliothèque json11 est une solution minimaliste et performante pour manipuler le format JSON en C++11. Développée initialement par Dropbox, elle se distingue par sa facilité d'intégration, ne nécessitant que deux fichiers pour fonctionner.

Intégration du projet

Pour utiliser json11, il suffit de récupérer les sources depuis son dépôt officiel et d'inclure les fichiers json11.hpp et json11.cpp directement dans votre arborescence de développement.

git clone https://github.com/dropbox/json11.git

Une fois les fichiers ajoutés, incluez simplement l'en-tête dans vos fichiers sources :

#include "json11.hpp"

Fonctionnalités fondamentales

1. Génération d'un objet JSON et sérialisation

La création de structures JSON s'appuie sur une syntaxe proche de l'initialisation des conteneurs standards C++.

using namespace json11;

// Construction d'un objet complexe
Json mon_objet = Json::object {
    { "utilisateur", "Jean_Dupont" },
    { "actif", true },
    { "scores", Json::array { 85, 92, 78 } },
};

// Conversion en chaîne de caractères (string)
std::string flux_json = mon_objet.dump();

2. Sérialisatino de types personnalisés

Il est aisé d'encapsuler la logique de conversion au sein de vos propres classes.

class Entree {
public:
    int id;
    std::string label;
    Entree(int i, std::string l) : id(i), label(l) {}

    // Méthode de conversion vers l'objet Json
    Json to_json() const { return Json::array { id, label }; }
};

std::vector<Entree> liste = { { 1, "Alpha" }, { 2, "Beta" } };
// Sérialisation automatique de la liste
std::string resultat = Json(liste).dump();

3. Analyse (Parsing) et extraction de données

Le parsing transforme une chaîne de caractères en un objet manipulable, tout en gérant les erreurs potenteilles via une chaîne de diagnostic.

std::string source = "{\"status\": 200, \"valide\": true, \"message\": \"Données reçues\"}";
std::string erreur;

// Analyse de la source
auto doc = Json::parse(source, erreur);

if (erreur.empty()) {
    int code = doc["status"].int_value();
    bool est_valide = doc["valide"].bool_value();
    std::string msg = doc["message"].string_value();
    
    // Vérification de l'existence d'une clé
    if (doc["metadata"].is_null()) {
        // Traitement si la clé est absente
    }
}

Exemple complet d'implémentation

Voici une structure type pour un projet utilisant CMake comme système de construction.

Structure des fichiers :``` . ├── CMakeLists.txt ├── json11.cpp ├── json11.hpp └── main.cpp

**Configuration CMake (CMakeLists.txt) :**```
cmake_minimum_required(VERSION 3.10)
project(DemoJson11)

set(CMAKE_CXX_STANDARD 11)

add_executable(DemoJson11 main.cpp json11.cpp)

Code source principal (main.cpp) :``` #include "json11.hpp" #include #include

int main() { // Exemple de création json11::Json config = json11::Json::object { {"version", 1.2}, {"encodage", "UTF-8"} }; std::cout << "JSON généré : " << config.dump() << std::endl;

// Exemple de lecture
std::string texte_brut = "{\"id\": 500, \"type\": \"admin\"}";
std::string err_msg;
auto parse_res = json11::Json::parse(texte_brut, err_msg);

if (err_msg.empty()) {
    std::cout << "ID : " << parse_res["id"].int_value() << std::endl;
    std::cout << "Type : " << parse_res["type"].string_value() << std::endl;
} else {
    std::cerr << "Erreur de parsing : " << err_msg << std::endl;
}

return 0;

}