如何在基于C++的GTK+应用中加载及读写XML文件？

Hey there! Since you're only a month into GTK+ development, let's break down how to handle XML loading, display, and editing in your C++ app clearly.

First off: GTK+ itself doesn't come with built-in XML parsing tools, but we can easily pair it with libxml2—a lightweight, widely used XML library that works seamlessly with C++ and GTK+. Let's walk through each step with code examples you can adapt.

First, make sure libxml2 is installed on your system. When compiling your app, link against both GTK+ (or gtkmm, the C++ binding for GTK+) and libxml2 using this command:

g++ your_app.cpp -o your_app `pkg-config --cflags --libs gtkmm-3.0 libxml-2.0`

In your C++ code, include the necessary headers:

#include <libxml/parser.h>
#include <libxml/tree.h>
#include <gtkmm.h>

Here's a helper function to load and validate an XML file using libxml2:

xmlDocPtr load_xml_file(const std::string& filename) {
    // Load the XML file
    xmlDocPtr doc = xmlReadFile(filename.c_str(), NULL, 0);
    if (doc == NULL) {
        g_printerr("Error: Failed to load XML file!\n");
        return NULL;
    }

    // Validate the root node (adjust this to match your XML structure)
    xmlNodePtr root = xmlDocGetRootElement(doc);
    if (root == NULL || xmlStrcmp(root->name, (const xmlChar*)"contacts")) {
        g_printerr("Error: Invalid XML structure—expected <contacts> root!\n");
        xmlFreeDoc(doc);
        return NULL;
    }

    return doc;
}

This function returns a xmlDocPtr (libxml2's document object) if loading succeeds, or NULL if something goes wrong.

Let's use a Gtk::TreeView (a common GTK+ list widget) to display your XML data. First, define a column structure for your data:

class Columns : public Gtk::TreeModel::ColumnRecord {
public:
    Columns() { add(col_name); add(col_email); }
    Gtk::TreeModelColumn<Glib::ustring> col_name;
    Gtk::TreeModelColumn<Glib::ustring> col_email;
};

Then, populate the TreeView with data from your loaded XML:

void populate_tree_view(xmlDocPtr doc, Gtk::TreeView& tree_view, const Columns& columns) {
    auto ref_list_store = Gtk::ListStore::create(columns);
    tree_view.set_model(ref_list_store);

    // Add columns to the TreeView
    tree_view.append_column("Name", columns.col_name);
    tree_view.append_column("Email", columns.col_email);

    // Traverse XML nodes to fill the store
    xmlNodePtr current_node = xmlDocGetRootElement(doc)->children;
    while (current_node != NULL) {
        if (!xmlStrcmp(current_node->name, (const xmlChar*)"contact")) {
            Gtk::TreeModel::Row row = *(ref_list_store->append());
            xmlNodePtr child_node = current_node->children;

            while (child_node != NULL) {
                xmlChar* content = xmlNodeGetContent(child_node);
                if (content == NULL) {
                    child_node = child_node->next;
                    continue;
                }

                if (!xmlStrcmp(child_node->name, (const xmlChar*)"name")) {
                    row[columns.col_name] = (const char*)content;
                } else if (!xmlStrcmp(child_node->name, (const xmlChar*)"email")) {
                    row[columns.col_email] = (const char*)content;
                }
                xmlFree(content); // Always free libxml2 allocated data!
                child_node = child_node->next;
            }
        }
        current_node = current_node->next;
    }
}

This code iterates through each <contact> node in your XML, extracts the name and email values, and adds them as rows to the TreeView.

When users modify data in the TreeView, you can write the changes back to an XML file with this helper function:

bool save_xml_file(const std::string& filename, Glib::RefPtr<Gtk::ListStore> ref_store, const Columns& columns) {
    // Create a new XML document
    xmlDocPtr doc = xmlNewDoc((const xmlChar*)"1.0");
    xmlNodePtr root = xmlNewNode(NULL, (const xmlChar*)"contacts");
    xmlDocSetRootElement(doc, root);

    // Traverse the TreeView data to build XML nodes
    for (const auto& row : ref_store->children()) {
        xmlNodePtr contact_node = xmlNewChild(root, NULL, (const xmlChar*)"contact", NULL);
        
        std::string name = row[columns.col_name];
        xmlNewChild(contact_node, NULL, (const xmlChar*)"name", (const xmlChar*)name.c_str());
        
        std::string email = row[columns.col_email];
        xmlNewChild(contact_node, NULL, (const xmlChar*)"email", (const xmlChar*)email.c_str());
    }

    // Save the document to file
    int result = xmlSaveFile(filename.c_str(), doc);
    xmlFreeDoc(doc); // Clean up

    if (result == -1) {
        g_printerr("Error: Failed to save XML file!\n");
        return false;
    }
    return true;
}

To trigger this save function, you could add a "Save" button in your GTK+ UI that calls it when clicked.

• Always clean up libxml2 resources: Functions like xmlNodeGetContent allocate memory that you must free with xmlFree to avoid leaks.
• Add user-friendly error messages: Instead of just printing to the console, use GTK+ dialogs (like Gtk::MessageDialog) to notify users of load/save failures.
• Handle complex XML: If your XML has attributes or deeper nesting, use libxml2's xmlGetProp to read attributes, and adjust node traversal logic to match your structure.

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