Arbeiten mit JSON in C++: Parsing und Serialisierung für Anfänger

Einleitung: Warum wird JSON in C++ benötigt?

JSON (JavaScript Object Notation) ist ein leichtgewichtiges Datenaustauschformat, das häufig in Webanwendungen, Konfigurationsdateien und APIs verwendet wird. Obwohl JSON ursprünglich in JavaScript entstand, ist es heute zum De-facto-Standard für die Übertragung strukturierter Daten zwischen Server und Client in jeder Programmiersprache, einschließlich C++, geworden.

In diesem Artikel werden wir uns ansehen, wie man mit JSON in C++ arbeitet: JSON-Daten parsen (lesen) und serialisieren (erstellen). Das Material richtet sich an Anfänger-Entwickler, die bereits mit den Grundlagen von C++ (Variablen, Funktionen, Klassen) vertraut sind, aber noch nicht mit JSON gearbeitet haben.

Für die Arbeit mit JSON in C++ verwenden wir die beliebte Bibliothek nlohmann/json (auch bekannt als JSON for Modern C++). Sie ist einfach zu installieren, intuitiv und hervorragend für das Lernen geeignet.

Installation der Bibliothek nlohmann/json

Bevor wir Code schreiben, muss die Bibliothek eingebunden werden. Der einfachste Weg ist die Verwendung der Header-only-Version (eine einzige Header-Datei ist ausreichend).

Methode 1: Datei json.hpp herunterladen

\n
• Gehen Sie zum GitHub-Repository von nlohmann/json.
\n
• Laden Sie die Datei json.hpp aus dem neuesten Release herunter.
\n
• Legen Sie sie in den Ordner Ihres Projekts.
\n
• Binden Sie sie im Code ein: #include "json.hpp"
\n

Methode 2: Paketmanager verwenden (vcpkg / Conan)

Wenn Sie CMake verwenden, ist es am einfachsten, die Bibliothek über vcpkg zu installieren:

vcpkg install nlohmann-json

Oder über Conan:

conan install nlohmann_json/3.11.2@

Nach der Installation binden Sie die Bibliothek im Code ein:

#include <nlohmann/json.hpp>\nusing json = nlohmann::json;

Jetzt können Sie loslegen!

JSON-Parsing in C++: Daten lesen

Parsing ist der Prozess der Umwandlung eines JSON-Strings in ein Objekt, mit dem im Code gearbeitet werden kann. Die Bibliothek nlohmann/json macht dies denkbar einfach.

Beispiel 1: Parsen eines JSON-Strings

Angenommen, wir haben einen JSON-String mit Informationen über einen Benutzer:

{\n  "name": "Alexej",\n  "age": 30,\n  "is_student": false,\n  "hobbies": ["Lesen", "Programmieren", "Fahrradfahren"]\n}

Das Parsing erfolgt in einer einzigen Zeile:

#include <iostream>\n#include <nlohmann/json.hpp>\n\nusing json = nlohmann::json;\n\nint main() {\n    // Ursprünglicher JSON-String\n    std::string json_str = R"(\n    {\n        "name": "Alexej",\n        "age": 30,\n        "is_student": false,\n        "hobbies": ["Lesen", "Programmieren", "Fahrradfahren"]\n    }\n    )";\n\n    // Parsing\n    json data = json::parse(json_str);\n\n    // Zugriff auf Daten\n    std::string name = data["name"];\n    int age = data["age"];\n    bool is_student = data["is_student"];\n    std::vector<std::string> hobbies = data["hobbies"];\n\n    // Ausgabe\n    std::cout << "Name: " << name << std::endl;\n    std::cout << "Alter: " << age << std::endl;\n    std::cout << "Student? " << (is_student ? "ja" : "nein") << std::endl;\n    std::cout << "Hobbys: ";\n    for (const auto& hobby : hobbies) {\n        std::cout << hobby << " ";\n    }\n    std::cout << std::endl;\n\n    return 0;\n}

Ergebnis der Ausführung:

Name: Alexej\nAlter: 30\nStudent? nein\nHobbys: Lesen Programmieren Fahrradfahren

Beispiel 2: Verarbeitung von verschachtelten Objekten

JSON enthält oft verschachtelte Strukturen. Betrachten wir ein Beispiel mit einer Adresse:

{\n  "user": {\n    "name": "Maria",\n    "address": {\n      "city": "Moskau",\n      "street": "Twerskaja"\n    }\n  }\n}

Zugriff auf verschachtelte Daten:

                
                

                    

                        Blogs                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
Rust auf GitHub: Die besten Open-Source-Projekte für Entwickler
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Algorithmen und Datenstrukturen in Java: Ein vollständiger Leitfaden für Anfänger
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Fehlerbehandlung in JavaScript: try/catch und mehr – vollständiger Leitfaden
                                
                            
                                            
                

                
                

                    

                        Buchempfehlungen                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
Architektur von C++-Anwendungen: Skalierbarkeit und Wartbarkeit
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Professionelles Go (Golang): fortgeschrittene Techniken
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Java-Webentwicklung: Von den Grundlagen bis zum Deployment
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Geheimnisse des JavaScript-Ninja
                                
                            
                                            
                
            
    

  
Lesen Sie auch
  

                
                  
                 Docker und JavaScript: Containerisierung von Node.js-Anwendungen (Fortgeschrittenenniveau)
      
                
                  
                 Feature Flags in Swift: flexible Konfiguration ohne neuen Build
      
                
                  
                 Wie man Swift-Entwickler wird: Tipps und Lebenslauf
      
                
                  
                 KI-Assistent in PHP: Wie man Code generiert, statt Bugs zu suchen
      
                
                  
                 Wer zum Teufel sind Fn, FnMut und FnOnce? Rust-Closures unter dem Mikroskop