Bekerja dengan struktur data XML di C boleh menggunakan perpustakaan TinyXML atau PugixML. 1) Gunakan perpustakaan PugixML untuk menghuraikan dan menghasilkan fail XML. 2) Mengendalikan elemen XML bersarang kompleks, seperti maklumat buku. 3) Mengoptimumkan kod pemprosesan XML, dan disyorkan untuk menggunakan perpustakaan yang cekap dan parsing streaming. Melalui langkah -langkah ini, data XML dapat diproses dengan cekap.

Pengenalan

Dalam pengaturcaraan moden, mengendalikan struktur data kompleks adalah tugas yang biasa dan kritikal, terutamanya apabila pertukaran data diperlukan dengan sistem atau format lain. XML (bahasa markup extensible) adalah bahasa markup yang digunakan secara meluas dan sering digunakan untuk pertukaran data dan fail konfigurasi. Hari ini kita akan menyelam bagaimana menangani XML di C, terutamanya bagaimana menangani struktur data yang kompleks. Melalui artikel ini, anda akan belajar cara menggunakan perpustakaan C untuk menghuraikan dan menghasilkan fail XML, cara mengendalikan elemen XML bersarang, dan bagaimana untuk mengoptimumkan kod pemprosesan XML anda.

Semak pengetahuan asas

XML adalah bahasa markup untuk menyimpan dan memindahkan data. Ia berstruktur sama dengan HTML tetapi lebih fleksibel dan boleh diperluaskan. Sebagai bahasa pengaturcaraan berprestasi tinggi, C menyediakan pelbagai perpustakaan untuk memproses data XML, di antaranya yang paling biasa digunakan ialah TinyXML dan PugixML.

TinyXML adalah parser XML yang ringan untuk persekitaran yang terkawal sumber, manakala PugixML dikenali dengan kecekapan dan kemudahan penggunaannya. Tidak kira perpustakaan yang anda pilih, memahami struktur asas XML dan pengurusan memori C adalah asas untuk memproses data XML.

Konsep teras atau analisis fungsi

Parsing dan Generasi XML

Pemprosesan XML dalam C terutamanya melibatkan dua aspek: parsing dan generasi. Parsing adalah untuk menukar fail XML ke objek C, sementara generasi adalah untuk menukar objek C ke fail XML.

Mari lihat contoh mudah, menggunakan perpustakaan PugixML untuk menghuraikan fail XML:

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

int main () {
    pugi :: xml_document doc;
    pugi :: xml_parse_result result = doc.load_file ("example.xml");

    jika (hasil) {
        pugi :: xml_node root = doc.child ("root");
        untuk (pugi :: xml_node child = root.first_child (); child; child = child.next_sibling ()) {
            std :: cout << "Node Nama:" << child.name () << ", nilai:" << child.child_value () << std :: endl;
        }
    } else {
        std :: cout << "ralat parsing xml:" << result.description () << std :: endl;
    }

    kembali 0;
}

Contoh ini menunjukkan cara memuatkan fail XML dan melepasi nodnya. Proses menghasilkan fail XML adalah serupa dengan ini, hanya buat nod dan tambahkannya ke dokumen.

Mengendalikan struktur data yang kompleks

Mengendalikan struktur data XML kompleks sering melibatkan unsur -unsur dan atribut bersarang. Mari kita lihat contoh yang lebih kompleks, katakan kita mempunyai fail XML yang mewakili maklumat buku:

 <pustakawan>
    <buku id = "1">
        <tirly> Tajuk buku </title>
        <throre> Nama Pengarang </pengarang>
        <bapter>
            <Bab Number = "1"> Bab 1 Kandungan </bab>
            <Bab Number = "2"> Bab 2 Kandungan </bab>
        </bab>
    </buku>
</perpustakaan>

Menggunakan PugixML, kita boleh menghuraikan struktur kompleks ini seperti ini:

 #include <pugixml.hpp>
#include <iostream>
#include <vector>
#include <string>

struct bab {
    nombor int;
    std :: kandungan rentetan;
};

Buku Struct {
    std :: string id;
    std :: title string;
    std :: string pengarang;
    std :: vektor <bab> bab;
};

int main () {
    pugi :: xml_document doc;
    pugi :: xml_parse_result result = doc.load_file ("Library.xml");

    jika (hasil) {
        pugi :: xml_node perpustakaan = doc.child ("perpustakaan");
        untuk (pugi :: xml_node book_node = perpustakaan.child ("buku"); book_node; book_node = book_node.next_sibling ("buku")) {
            Buku buku;
            book.id = book_node.attribute ("id"). nilai ();
            book.title = book_node.child ("Tajuk"). Child_Value ();
            book.author = book_node.child ("pengarang"). Child_value ();

            pugi :: xml_node chapters_node = book_node.child ("bab");
            untuk (pugi :: xml_node bab_node = chapters_node.child ("bab"); bab_node; bab_node = bab_node.next_sibling ("bab")) {
                Bab bab;
                bab.number = std :: stoi (bab_node.attribute ("nombor"). nilai ());
                bab.content = bab_node.child_value ();
                book.chapters.push_back (bab);
            }

            // Maklumat buku output std :: cout << "id buku:" << book.id << ", tajuk:" << book.title << ", pengarang:" << book.author << std :: endl;
            untuk (const auto & bab: book.chapters) {
                std :: cout << "bab" << bab.number << ":" << bab.content << std :: endl;
            }
        }
    } else {
        std :: cout << "ralat parsing xml:" << result.description () << std :: endl;
    }

    kembali 0;
}

Contoh ini menunjukkan bagaimana untuk menghuraikan struktur XML yang kompleks ke dalam objek C dan mengeluarkan kandungannya.

Contoh penggunaan

Penggunaan asas

Penggunaan asas termasuk memuatkan fail XML, melintasi nod, dan mengakses nilai nod. Kami telah menunjukkan operasi ini dalam contoh sebelumnya. Berikut adalah contoh asas untuk menghasilkan fail XML:

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

int main () {
    pugi :: xml_document doc;
    Auto Declaration = doc.append_child (Pugi :: node_declaration);
    Declaration.append_attribute ("versi") = "1.0";
    Declaration.Append_Attribute ("pengekodan") = "UTF-8";

    Auto root = doc.append_child ("root");
    Auto Child = root.append_child ("anak");
    child.append_child (pugi :: node_pcdata) .set_value ("Hello, World!");

    doc.save_file ("output.xml");

    kembali 0;
}

Contoh ini mewujudkan fail XML yang mudah yang mengandungi nod akar dan nod kanak -kanak.

Penggunaan lanjutan

Penggunaan lanjutan mungkin melibatkan pemprosesan struktur XML yang lebih kompleks, seperti pengendalian ruang nama, bahagian CDATA, dan arahan pengendalian. Mari lihat contoh berurusan dengan ruang nama:

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

int main () {
    pugi :: xml_document doc;
    pugi :: xml_parse_result result = doc.load_file ("namespaced.xml");

    jika (hasil) {
        pugi :: xml_node root = doc.child ("root");
        pugi :: xml_namespace ns = root.namespace ();
        std :: cout << "namespace uri:" << ns.uri () << std :: endl;

        untuk (pugi :: xml_node child = root.first_child (); child; child = child.next_sibling ()) {
            jika (child.namespace (). uri () == ns.uri ()) {
                std :: cout << "Node Nama:" << child.name () << ", nilai:" << child.child_value () << std :: endl;
            }
        }
    } else {
        std :: cout << "ralat parsing xml:" << result.description () << std :: endl;
    }

    kembali 0;
}

Contoh ini menunjukkan cara mengendalikan fail XML dengan ruang nama.

Kesilapan biasa dan tip debugging

Kesalahan biasa apabila mengendalikan XML termasuk ralat format XML, nod atau kegagalan atribut, dan isu pengurusan memori. Berikut adalah beberapa petua debug:

• Gunakan alat pengesahan XML (seperti XMLLINT) untuk memeriksa sama ada fail XML diformat dengan betul.
• Apabila parsing XML, periksa sama ada hasil parsing berjaya dan mengeluarkan mesej ralat.
• Gunakan debugger atau pembalakan untuk menjejaki proses pelaksanaan kod untuk membantu mencari masalah.
• Pastikan memori diuruskan dengan betul, terutamanya apabila menggunakan perpustakaan yang diuruskan memori manual.

Pengoptimuman prestasi dan amalan terbaik

Pengoptimuman prestasi dan amalan terbaik sangat penting apabila berurusan dengan XML. Berikut adalah beberapa cadangan:

• Gunakan perpustakaan XML yang cekap seperti PuGixML, yang melaksanakan dengan baik apabila menghuraikan dan menjana XML.
• Elakkan operasi DOM yang kerap dan cuba membina atau mengubah suai struktur XML pada satu masa.
• Gunakan parsing streaming (seperti parsing sax) untuk memproses fail XML yang besar dan mengurangkan penggunaan memori.
• Untuk data XML yang sering diakses, pertimbangkan cache ke ingatan untuk meningkatkan kelajuan akses.

Dalam aplikasi praktikal, adalah berguna untuk membandingkan perbezaan prestasi antara kaedah yang berbeza. Sebagai contoh, bandingkan prestasi parsing Dom dan parsing Sax semasa memproses fail XML yang besar:

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

void Domparse (const char* filename) {
    pugi :: xml_document doc;
    Auto start = std :: chrono :: high_resolution_clock :: sekarang ();
    doc.load_file (nama fail);
    Auto end = std :: chrono :: high_resolution_clock :: sekarang ();
    Auto Duration = std :: chrono :: duration_cast <std :: chrono :: milliseconds> (end - start) .count ();
    std :: cout << "dom parse time:" << durasi << "ms" << std :: endl;
}

void saxparse (const char* filename) {
    pugi :: xml_document doc;
    pugi :: xml_parse_result hasil;
    Auto start = std :: chrono :: high_resolution_clock :: sekarang ();
    pugi :: xml_parser parser;
    parser.parse_file (nama fail, hasil);
    Auto end = std :: chrono :: high_resolution_clock :: sekarang ();
    Auto Duration = std :: chrono :: duration_cast <std :: chrono :: milliseconds> (end - start) .count ();
    std :: cout << "Sax Parse Time:" << durasi << "MS" << std :: endl;
}

int main () {
    const char* filename = "large_file.xml";
    Komparse (nama fail);
    SaxParse (nama fail);
    kembali 0;
}

Contoh ini menunjukkan bagaimana untuk membandingkan perbezaan prestasi antara parsing dom dan parsing sax.

Apabila menulis kod pemprosesan XML, ia juga sangat penting untuk memastikan kod itu boleh dibaca dan dikekalkan. Menggunakan nama pembolehubah yang bermakna, menambah komen, dan mengikuti panduan gaya kod boleh meningkatkan kualiti kod.

Singkatnya, pengendalian XML adalah tugas yang biasa dan penting dalam C. Dengan memilih perpustakaan yang betul, memahami struktur XML, dan menggunakan pengoptimuman prestasi dan amalan terbaik, anda dapat mengendalikan struktur data XML yang kompleks. Semoga artikel ini memberikan anda pandangan yang berharga dan contoh kod berguna.

Atas ialah kandungan terperinci XML di C: Mengendalikan struktur data kompleks. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!