SoFunction
Updated on 2025-04-13

Techniques and methods for operating XML files in C language

summary

XML (extensible markup language) is widely used in data exchange, configuration files, web services and other fields due to its flexibility and standardization characteristics. As an efficient and underlying programming language, C language has also been widely used in processing XML data. This article will explore the techniques and methods of C language operating XML to help readers master the skills of C language processing XML. The main contents include the basic concept of XML, the introduction of common libraries for operating XML in C language, the specific steps for parsing and generating XML files using the libxml2 library, and the precautions in actual applications.

1. Introduction

With the increase in the demand for Internet and data exchange, XML (Extensible Markup Language) is widely used in various fields as a standardized data format. As an efficient and underlying programming language, C language also has important application value in processing XML data. This article will introduce in detail how to manipulate XML files in C language, including parsing XML documents, generating XML documents, traversing XML nodes, etc., aiming to provide readers with a comprehensive guide.

2. Basic concepts of XML

2.1 Introduction to XML

XML (Extensible Markup Language) is a markup language used to store and transfer data. It is similar to HTML, but its main purpose is to store and transfer data, not display it. XML is designed to transmit and store data, while HTML is designed to display data. XML tags are not predefined, users need to define tags by themselves. XML is designed to be self-descriptive, with each element having a clear meaning.

2.2 XML document structure

A typical XML document consists of the following parts:

  • statement: The beginning of an XML document usually contains a declaration indicating the XML version and encoding method. For example:
<?xml version="1.0" encoding="UTF-8"?>
  • Root element: The XML document must have a root element, which is the parent of all other elements. For example:
&lt;root&gt;
    &lt;!-- Other elements --&gt;
&lt;/root&gt;
  • Sub-elements: The root element can contain multiple child elements. For example:
<root>
    <child1>Value1</child1>
    <child2>Value2</child2>
</root>
  • property: Elements can contain attributes to provide additional information. For example:
<root>
    <child1 >Value1</child1>
</root>

2.3 Advantages of XML

The main advantages of XML include:

  • Scalability: Users can customize tags to meet various data storage and transmission needs.
  • standardization: XML complies with international standards to ensure data interoperability and compatibility.
  • Self-descriptive: XML documents have clear structure, easy to understand and parse.
  • Platform irrelevance: XML documents can be exchanged and processed on different operating systems and platforms.

3. Common libraries for C language operation XML

3.1 libxml2 library

3.1.1 Introduction to libxml2 library

libxml2 is a powerful C language XML parsing library that supports various functions such as XML, HTML and XPath. It has the following characteristics:

  • Support XML and HTML parsing
  • Support XPath query
  • Support XML Schema verification
  • Supports XML read and write operations
  • Supports multi-threading

3.1.2 Installation of libxml2 library

On Linux systems, you can install the libxml2 library through the following command:

sudo apt-get install libxml2-dev

On Windows systems, you can install the libxml2 library through the following steps:

  • Download the source code of libxml2: /GNOME/libxml2
  • Compile source code: Open the command prompt of Visual Studio, enter the libxml2 source code directory, and execute the following command:
nmake /f
  • Installation library: Copy the compiled and libxml2_a.lib to the lib folder in the project directory, and copy the header file to the include folder in the project directory.

3.2 Expat library

3.2.1 Introduction to Expat library

Expat is a lightweight C language XML parsing library. It only provides XML parsing functions, not XML writing and XPath querying functions. It has the following characteristics:

  • Lightweight
  • Fast parsing speed
  • Suitable for embedded devices

3.2.2 Installation of Expat library

On Linux systems, you can install the Expat library through the following command:

sudo apt-get install libexpat-dev

On Windows systems, you can install the Expat library by following the steps:

  • Download the source code of Expat: /libexpat/libexpat
  • Compile source code: Open the Visual Studio command prompt, enter the Expat source code directory, and execute the following command:
nmake /f
  • Installation library: Copy the compiled and libexpat_a.lib to the lib folder in the project directory, and copy the header file to the include folder in the project directory.

3.3 Mini-XML Library

3.3.1 Introduction to Mini-XML Library

Mini-XML is a small C language XML parsing library that provides simple XML parsing and writing capabilities, suitable for small projects and embedded devices. It has the following characteristics:

  • Simple and easy to use
  • Small size, suitable for embedded devices
  • Supports XML parsing and writing

3.3.2 Installation of Mini-XML library

On Linux systems, you can install the Mini-XML library through the following command:

sudo apt-get install libmxml-dev

On Windows systems, you can install the Mini-XML library by following the steps:

  • Download the source code of Mini-XML:/
  • Compile source code: Open the command prompt of Visual Studio, enter the Mini-XML source code directory, and execute the following command:
nmake /f
  • Installation library: Copy the compiled and mxml_a.lib to the lib folder in the project directory, and copy the header file to the include folder in the project directory.

4. Use libxml2 library to parse XML files

4.1 Parsing XML documents

The basic steps for parsing XML documents using libxml2 are as follows:

  • Initialize the XML parser: Before using libxml2, the XML parser needs to be initialized.
xmlInitParser();
  • Create XML Document:usexmlReadFileThe function reads XML content from the file and creates an XML document object.
xmlDocPtr doc = xmlReadFile("", NULL, XML_PARSE_NOBLANKS);
if (doc == NULL) {
    fprintf(stderr, "Error: unable to parse file %s\n", "");
    return -1;
}
  • Get the root element:passxmlDocGetRootElementFunctions get the root element of the XML document.
xmlNodePtr root_element = xmlDocGetRootElement(doc);

Iterate through XML elements: Iterate through elements of an XML document using recursion or loop.

void print_element_names(xmlNodePtr element) {
    xmlNodePtr child = NULL;
    for (child = element; child; child = child->next) {
        if (child->type == XML_ELEMENT_NODE) {
            printf("Element: %s\n", child->name);
        }
        print_element_names(child->children);
    }
}
print_element_names(root_element);

Release XML document: After completing the operation of the XML document, you need to release the XML document object.

xmlFreeDoc(doc);
xmlCleanupParser();

4.2 Query XML using XPath

libxml2 supports XPath, a language used to query XML documents. Using XPath allows you to conveniently locate specific XML elements.

  • Compile XPath expressions:usexmlXPathCompileFunctions compile XPath expressions.
xmlXPathContextPtr xpathCtx = xmlXPathNewContext(doc);
xmlXPathObjectPtr xpathObj = xmlXPathEvalExpression(BAD_CAST "//book/title/text()", xpathCtx);
  • Process XPath query results: traverse the query results and extract the required information.
if (xpathObj && xpathObj->nodesetval) {
    for (int i = 0; i < xpathObj->nodesetval->nodeNr; i++) {
        xmlNodePtr node = xpathObj->nodesetval->nodeTab[i];
        if (node && node->type == XML_TEXT_NODE) {
            printf("Title: %s\n", node->content);
        }
    }
}

Clean up XPath context: Release XPath context and query results.

xmlXPathFreeObject(xpathObj);
xmlXPathFreeContext(xpathCtx);

4.3 Advanced functions for parsing XML files

4.3.1 Handling namespaces

An XML document can contain namespaces that distinguish elements from different sources. Use the libxml2 library to handle namespaces easily.

xmlNsPtr ns = xmlSearchNsByHref(doc, node, BAD_CAST "/namespace");
if (ns) {
    printf("Namespace prefix: %s\n", ns->prefix);
}

4.3.2 Verifying XML Documents

The libxml2 library supports XML Schema verification to ensure that the XML document complies with predetermined structures and rules.

xmlSchemaPtr schema = xmlSchemaParse(doc, NULL);
if (schema) {
    xmlSchemaValidCtxtPtr validCtxt = xmlSchemaNewValidCtxt(schema);
    if (validCtxt) {
        int isValid = xmlSchemaValidateDoc(validCtxt, doc);
        if (isValid == 0) {
            printf("XML Document Verification Passed\n");
        } else {
            printf("XML document verification failed\n");
        }
        xmlSchemaFreeValidCtxt(validCtxt);
    }
    xmlSchemaFree(schema);
}

5. Generate XML files using libxml2 library

5.1 Creating XML Documents

The basic steps for creating an XML document are as follows:

  • Create XML document object:usexmlNewDocFunction creates a new XML document object.
xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
  • Create a root element:usexmlNewNodeFunction creates the root element.
xmlNodePtr root_node = xmlNewNode(NULL, BAD_CAST "root");
  • Set the root element:usexmlDocSetRootElementThe function sets the root element as the root node of the document.
xmlDocSetRootElement(doc, root_node);
  • Add child nodes:usexmlNewTextChildThe function creates child nodes and adds them to the root node.
xmlNewTextChild(root_node, NULL, BAD_CAST "child1", BAD_CAST "Value1");

Set properties:usexmlNewPropFunctions add properties to nodes.

xmlNewProp(root_node, BAD_CAST "id", BAD_CAST "1");

5.2 Save XML documents

Save the XML document to a file:

  • Save to file:usexmlSaveFileFunction saves XML document to a file.
int result = xmlSaveFile("", doc);
if (result != -1) {
    printf("XML document saved to file \n");
}
  • Release the document: Release XML document object.
xmlFreeDoc(doc);
xmlCleanupParser();

5.3 Advanced features for generating XML files

5.3.1 Add comments

Adding comments to the generated XML document can improve the readability of the document.

xmlAddChild(root_node, xmlNewComment(BAD_CAST "This is a comment"));

5.3.2 Adding CDATA section

The CDATA section is used to contain text content that does not require parsing, and is often used to contain HTML code or other special characters.

xmlAddChild(root_node, xmlNewCDataBlock(doc, BAD_CAST "<html><body>Hello, World!</body></html>", 38));

6. Things to note in practical application

6.1 Error handling

When using the libxml2 library, you need to pay attention to error handling. Most functions will return an error code or NULL, indicating that the operation has failed. These return values ​​should be checked and error-handled.

xmlDocPtr doc = xmlReadFile("", NULL, XML_PARSE_NOBLANKS);
if (doc == NULL) {
    fprintf(stderr, "Error: unable to parse file %s\n", "");
    return -1;
}

6.2 Memory Management

The libxml2 library dynamically allocates memory when parsing and generating XML documents. After the operation is completed, the memory needs to be freed to avoid memory leakage. usexmlFreeDocFunction releases document object, usexmlCleanupParserFunction clearing parser.

xmlFreeDoc(doc);
xmlCleanupParser();

6.3 Character encoding

XML documents are usually encoded using UTF-8. When parsing and generating XML documents, you need to make sure you use the correct encoding method. AvailablexmlReadFileThe third parameter of the function specifies the encoding method.

xmlDocPtr doc = xmlReadFile("", "UTF-8", XML_PARSE_NOBLANKS);

6.4 Performance optimization

For large XML documents, consider using streaming parsing (such as SAX parsers) to improve performance. The SAX parser does not load the entire document into memory, but parses the document line by line, suitable for handling large files.

xmlSAXHandler saxHandler = {0};
 = startElementCallback;
 = endElementCallback;
 = charactersCallback;

xmlSAXUserParseFile(&saxHandler, NULL, "large_file.xml");

6.5 Concurrent processing

When using the libxml2 library in a multi-threaded environment, you need to pay attention to thread safety. The libxml2 library provides some thread-safe functions and mechanisms, but needs to be used correctly.

xmlInitParser();
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
xmlSetGenericErrorFunc(NULL, myErrorHandler);

xmlDocPtr doc = xmlReadFile("", NULL, XML_PARSE_NOBLANKS);
if (doc == NULL) {
    fprintf(stderr, "Error: unable to parse file %s\n", "");
    return -1;
}

// Use multithreading to process XML documentspthread_t threads[NUM_THREADS];
for (int i = 0; i &lt; NUM_THREADS; i++) {
    pthread_create(&amp;threads[i], NULL, processThread, (void *)doc);
}

for (int i = 0; i &lt; NUM_THREADS; i++) {
    pthread_join(threads[i], NULL);
}

xmlFreeDoc(doc);
xmlCleanupParser();

7. Conclusion

This article introduces in detail the techniques and methods of operating XML files in C language, including the basic concepts of XML, the introduction of common libraries for operating XML in C language, the specific steps for parsing and generating XML files using the libxml2 library, and the precautions in actual applications. Through the study of this article, readers should be able to deeply understand these basic knowledge and be able to flexibly apply them in actual programming.

The above is the detailed content of the techniques and methods of operating XML files in C language. For more information about operating XML files in C language, please pay attention to my other related articles!