使用libcurl+rapidJSON解析JSON遇空DOM问题求助

Hey there! I totally get how frustrating this is when you're just starting out—you pull data from an API, but your parser just won't cooperate. Let's walk through the most common reasons your rapidJSON Document is ending up null, and how to fix them step by step.

1. First: Verify libcurl is actually returning valid JSON #

Before pointing fingers at rapidJSON, make sure libcurl is fetching real, valid JSON data. It's super easy to accidentally get an empty response, an error page (like 404/500 HTML), or malformed data without noticing.

Here's a robust way to capture your libcurl response and print it for checking:

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

// Callback function to write curl response into a string
size_t writeCallback(void* contents, size_t size, size_t nmemb, std::string* s) {
    size_t newLen = size * nmemb;
    try {
        s->append((char*)contents, newLen);
    } catch (const std::bad_alloc&) {
        return 0; // Signal curl we couldn't write data
    }
    return newLen;
}

int main(int argc, const char* argv[]) {
    std::string responseData;
    CURL* curl = curl_easy_init();

    if (curl) {
        // Set your API URL and POST options
        curl_easy_setopt(curl, CURLOPT_URL, "https://your-api-endpoint.com");
        curl_easy_setopt(curl, CURLOPT_POST, 1L);
        // Uncomment if you need to send POST data
        // curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "key1=value1&key2=value2");
        
        // Route response to our string via callback
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &responseData);

        // Execute the request
        CURLcode res = curl_easy_perform(curl);
        if (res != CURLE_OK) {
            std::cerr << "Curl failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            // Print the raw response to check if it's valid JSON!
            std::cout << "Raw Response:\n" << responseData << "\n\n";
        }

        curl_easy_cleanup(curl);
    }

    // Now parse with rapidJSON...
    // (see next section)
    return 0;
}

Run this and check the output. If you see anything other than clean, valid JSON (like HTML error messages), fix your curl request first (check URL, POST data, authentication, etc.).

2. Fix your rapidJSON parsing code #

The biggest mistake I see newbies make is initializing the Document incorrectly. Your code has doc.SetObject();—that creates an empty object DOM, which will interfere with parsing the actual JSON!

Correct parsing steps: #

// Inside main, after getting responseData...
rapidjson::Document doc;
// Parse the response string directly—DO NOT call SetObject() first!
rapidjson::ParseResult parseResult = doc.Parse(responseData.c_str());

// Check if parsing succeeded
if (!parseResult) {
    std::cerr << "JSON Parse Error: " 
              << rapidjson::GetParseError_En(parseResult.Code())
              << " at offset " << parseResult.Offset() << std::endl;
    return 1;
}

// Now doc is a valid DOM! Let's use it
if (doc.IsObject()) {
    // Example: Get a string field named "message"
    if (doc.HasMember("message") && doc["message"].IsString()) {
        std::cout << "API Message: " << doc["message"].GetString() << std::endl;
    }
    // Example: Get an integer field named "code"
    if (doc.HasMember("code") && doc["code"].IsInt()) {
        std::cout << "Status Code: " << doc["code"].GetInt() << std::endl;
    }
}

Why this works: The Parse() method initializes the Document with the JSON data. Calling SetObject() first overrides the Document to be an empty object, so parsing the real JSON either fails or gets ignored.

3. Check for encoding/format issues #

RapidJSON expects UTF-8 encoded JSON by default. If your API returns another encoding (like GBK), you'll need to convert it to UTF-8 first. Also, make sure the JSON has no trailing garbage characters (like extra newlines or whitespace at the end) that could break parsing.

You can manually validate the responseData string with any JSON validator tool to confirm it's well-formed.

4. Avoid memory mistakes #

If you were using a raw char* to store the curl response instead of std::string, make sure the memory isn't freed before parsing. Using std::string is safer here because it manages memory automatically.

内容的提问来源于stack exchange，提问作者LosReturn