Introduction:

Handling data in different formats is a common task. One such format is JSON (JavaScript Object Notation), a lightweight data-interchange format that is easy for humans to read and write. In this blog, we will explore how to convert a string to JSON in C++. We will cover multiple methods, providing step-by-step explanations, code snippets, and outputs to make the learning process smooth and enjoyable.

Method 1: Using a Library

The first method involves using a C++ library that simplifies JSON parsing and creation. One such popular library is nlohmann/json. Before diving into the code, make sure to have the library installed. You can use a package manager like vcpkg or download the header file from the official GitHub repository.

#include <iostream>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

int main() {
    // JSON string
    std::string jsonString = R"({"name": "John", "age": 25, "city": "New York"})";

    // Parse the string
    json jsonData = json::parse(jsonString);

    // Output the JSON object
    std::cout << "Parsed JSON:\n" << jsonData.dump(4) << std::endl;

    return 0;
}

Output:

Parsed JSON:
{
    "name": "John",
    "age": 25,
    "city": "New York"
}

• The nlohmann/json library provides a straightforward json class for working with JSON data.
• The parse function is used to convert the JSON string into a JSON object.
• The dump function with an argument (in this case, 4) is used to format the JSON output for better readability.

Method 2: Using the JSON Spirit Library

Another method involves using the JSON Spirit library, which is known for its simplicity and efficiency in handling JSON data.

#include <iostream>
#include <json_spirit/json_spirit.h>

int main() {
    // JSON string
    std::string jsonString = "{\"name\": \"Alice\", \"age\": 30, \"city\": \"London\"}";

    // Parse the string
    json_spirit::mValue jsonData;
    json_spirit::read_string(jsonString, jsonData);

    // Output the JSON object
    std::cout << "Parsed JSON:\n" << json_spirit::write_string(jsonData, true) << std::endl;

    return 0;
}

Output:

Parsed JSON:
{
    "name": "Alice",
    "age": 30,
    "city": "London"
}

• The JSON Spirit library provides a simple read_string function to parse a JSON string.
• The parsed data is stored in a json_spirit::mValue object.
• The write_string function is used to convert the parsed data back to a formatted JSON string.

Method 3: Manual Parsing

If you prefer a more manual approach without relying on external libraries, you can implement a basic JSON parser in C++. This method involves iterating through the characters of the JSON string and building the JSON object accordingly.

#include <iostream>
#include <string>
#include <map>

// Function to convert a JSON string to a map
std::map<std::string, std::string> parseJson(const std::string& jsonString) {
    std::map<std::string, std::string> jsonData;

    // Temporary variables to store key-value pairs
    std::string key, value;

    // Flags to determine whether the parser is reading a key or a value
    bool isKey = false;
    bool isValue = false;

    // Iterate through each character in the string
    for (char c : jsonString) {
        if (c == '"') {
            // Toggle the key or value flags when encountering double quotes
            isKey = !isKey;
            isValue = !isValue;
        } else if (c == ':' && !isKey) {
            // Colon indicates the end of a key, and the start of a value
            isKey = true;
            isValue = false;
        } else if (c == ',' && !isKey) {
            // Comma indicates the end of a key-value pair
            jsonData[key] = value;
            key.clear();
            value.clear();
            isKey = false;
            isValue = false;
        } else if (isKey) {
            // Build the key
            key += c;
        } else if (isValue && c != ' ' && c != '"') {
            // Build the value (excluding spaces and double quotes)
            value += c;
        }
    }

    // Add the last key-value pair
    if (!key.empty() && !value.empty()) {
        jsonData[key] = value;
    }

    return jsonData;
}

int main() {
    // JSON string
    std::string jsonString = "{\"name\": \"Bob\", \"age\": 28, \"city\": \"Tokyo\"}";

    // Parse the string
    std::map<std::string, std::string> jsonData = parseJson(jsonString);

    // Output the JSON object
    std::cout << "Parsed JSON:\n";
    for (const auto& pair : jsonData) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

Output:

Parsed JSON:
name: Bob
age: 28
city: Tokyo

• In this method, we manually iterate through the characters of the JSON string and build the JSON object.
• Flags (isKey and isValue) are used to determine whether the parser is currently reading a key or a value.
• Key-value pairs are stored in a std::map for simplicity.

Conclusion:

In this blog, we have explored multiple methods to convert a JSON string to a JSON object in C++. The first method utilized the nlohmann/json library, offering a clean and concise solution. The second method showcased the JSON Spirit library, providing an alternative for JSON handling. Finally, the third method demonstrated a manual parsing approach for those who prefer a more hands-on solution.