Boost Your C++ Apps with RapidJSON and pugixml: A Practical Guide

In modern C++ application development, exchanging data with external systems or persisting complex structures often requires JSON or XML, which are not natively supported by the standard library.

1. Why use third‑party libraries?

Manual parsing is error‑prone and inefficient. Libraries like RapidJSON and pugixml offer high performance, ease of use, lightweight integration, and robustness.

High performance: optimized parsing and serialization speed.

Ease of use: intuitive APIs.

Lightweight: header‑only or minimal compiled files.

Robustness: handle edge cases and format errors.

2. RapidJSON: a fast JSON parser/generator

Integration and installation

RapidJSON is header‑only; simply download the include/rapidjson directory and add it to your project’s include path.

git clone https://github.com/Tencent/rapidjson.git
# then add rapidjson/include to your compiler

Core usage: DOM API

The DOM API parses a JSON document into an in‑memory tree for random access and modification.

Example: parse a JSON string and read values

#include "rapidjson/document.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/writer.h"
#include <iostream>
#include <string>

using namespace rapidjson;

int main() {
    // 1. Prepare a JSON string
    const char* json = R"(
        {
            "name": "Alice",
            "age": 30,
            "is_student": false,
            "courses": ["C++", "Data Structures"]
        })";
    // 2. Parse into Document
    Document document;
    document.Parse(json);
    // 3. Check root is object
    if (document.IsObject()) {
        // 4. Access members
        if (document.HasMember("name") && document["name"].IsString()) {
            std::string name = document["name"].GetString();
            std::cout << "Name: " << name << std::endl;
        }
        if (document.HasMember("age") && document["age"].IsInt()) {
            int age = document["age"].GetInt();
            std::cout << "Age: " << age << std::endl;
        }
        // 5. Access array
        if (document.HasMember("courses") && document["courses"].IsArray()) {
            const Value& courses = document["courses"];
            std::cout << "Courses: ";
            for (SizeType i = 0; i < courses.Size(); i++) {
                std::cout << courses[i].GetString() << " ";
            }
            std::cout << std::endl;
        }
    }
    return 0;
}

Example: create and generate JSON

int main() {
    Document document;
    document.SetObject(); // set as object
    rapidjson::Document::AllocatorType& allocator = document.GetAllocator();

    // add key‑value pairs
    Value name_val;
    name_val.SetString("Bob", allocator);
    document.AddMember("name", name_val, allocator);
    document.AddMember("score", 95.5, allocator);

    // create an array
    Value arr(kArrayType);
    arr.PushBack("Reading", allocator).PushBack("Swimming", allocator);
    document.AddMember("hobbies", arr, allocator);

    // convert to string
    StringBuffer buffer;
    Writer<StringBuffer> writer(buffer);
    document.Accept(writer);
    std::string json_str = buffer.GetString();
    std::cout << "Generated JSON: " << json_str << std::endl;
    return 0;
}

3. pugixml: lightweight XML processor

pugixml is a simple, efficient C++ XML library with XPath 1.0 support.

Integration and installation

Download the source from the official site or GitHub, add src/pugixml.cpp and include src/pugixml.hpp in your project.

Core usage

Example: load and parse an XML file

Assume a config.xml file:

<?xml version="1.0"?>
<config>
    <log level="info" path="/var/log/app.log"/>
    <server ip="192.168.1.100" port="8080"/>
    <users>
        <user id="1">Alice</user>
        <user id="2">Bob</user>
    </users>
</config>

#include "pugixml.hpp"
#include <iostream>

int main() {
    pugi::xml_document doc;
    // load XML file
    pugi::xml_parse_result result = doc.load_file("config.xml");
    if (!result) {
        std::cerr << "XML parsed with errors: " << result.description() << std::endl;
        return -1;
    }
    // node traversal
    std::cout << "--- Node Traversal ---" << std::endl;
    pugi::xml_node config = doc.child("config");
    pugi::xml_node log = config.child("log");
    pugi::xml_node server = config.child("server");
    // read attributes
    std::cout << "Log Level: " << log.attribute("level").as_string() << std::endl;
    std::cout << "Server IP: " << server.attribute("ip").as_string() << ":" << server.attribute("port").as_int() << std::endl;
    // iterate children
    pugi::xml_node users = config.child("users");
    for (pugi::xml_node user : users.children("user")) {
        std::cout << "User ID: " << user.attribute("id").as_int()
                  << ", Name: " << user.text().as_string() << std::endl;
    }
    // XPath query
    std::cout << "
--- XPath Query ---" << std::endl;
    pugi::xpath_node_set xpath_users = doc.select_nodes("/config/users/user");
    for (pugi::xpath_node node : xpath_users) {
        pugi::xml_node user = node.node();
        std::cout << "User (XPath): " << user.text().as_string() << std::endl;
    }
    // find specific attribute node
    pugi::xpath_node log_node = doc.select_node("//log[@level='info']");
    if (log_node) {
        std::cout << "Found log path: " << log_node.node().attribute("path").as_string() << std::endl;
    }
    return 0;
}

Example: create and save XML

#include "pugixml.hpp"

int main() {
    pugi::xml_document doc;
    // add declaration
    auto declaration = doc.append_child(pugi::node_declaration);
    declaration.append_attribute("version") = "1.0";
    declaration.append_attribute("encoding") = "UTF-8";

    // create root
    auto root = doc.append_child("root");

    // add child items
    auto item = root.append_child("item");
    item.append_attribute("id") = 1;
    item.text() = "Hello";

    auto another_item = root.append_child("item");
    another_item.append_attribute("id") = 2;
    another_item.text() = "World";

    // save to file
    doc.save_file("output.xml", "  ");
    return 0;
}

4. Summary and selection

Choose RapidJSON when you need ultra‑fast JSON handling, especially in networking, game development, or high‑frequency logging. Choose pugixml for configuration files or legacy systems where XML and XPath make data extraction easy.

These lightweight yet powerful libraries enable C++ developers to integrate JSON and XML parsing and serialization into projects efficiently.