Cómo usar tinyxml para procesar xml y prestar atención a los problemas

El código de copia es el siguiente:

lt;Personsgt;

lt;Persongt; >lt;namegt;lhylt ;/namegt;

lt;agegt;22lt;/agegt;

lt;/Personsgt

lt;/Personsgt;

En el blog anterior, también presentamos todas las clases en el analizador tinyxml y las relaciones entre clases.

Para crear xml en el formato anterior, el código es el siguiente:

Copiar el código El código es el siguiente:

//Crear un documento XML objeto.

TiXmlDocument *myDocument = new TiXmlDocument();

//Crea un elemento raíz y concatena.

TiXmlElement *RootElement = new TiXmlElement("Persons") ;

myDocument-gt;LinkEndChild(RootElement);

//Crea un elemento Persona y vincúlalo.

TiXmlElement *PersonElement = new TiXmlElement("Persona ");

RootElement-gt; LinkEndChild(PersonElement);

// Crea elementos de nombre, elementos de edad y vincúlalos.

TiXmlElement *NameElement = new TiXmlElement("nombre");

TiXmlElement *AgeElement = new TiXmlElement("edad");

PersonElement -gt; (NameElement);

PersonElement-gt; LinkEndChild(AgeElement);

// Establece el contenido del elemento de nombre y del elemento de edad y conéctalos.

TiXmlText *NameContent = nuevo TiXmlText("lhy");

TiXmlText *AgeContent = nuevo TiXmlText("22");

NameElement-gt.LinkEndChild (NameContent);

AgeElement-gt; LinkEndChild(AgeContent);

myDocument-gt;

Siempre que comprenda las relaciones entre los nodos en el xml, la creación no es un problema. Para decirlo sin rodeos, se trata de una relación intergeneracional.

La creación está completa, pero como programador de C, siempre me siento un poco incómodo después de escribirlo y siempre siento que algo anda mal. ¿Has descubierto también sus trucos?

Por cierto, algunos códigos tienen muchos punteros nuevos.

C no tiene el mecanismo de recolección de basura de Java, usted mismo debe lidiar con la basura. ¿Pero no hay ninguna declaración de eliminación en el código?

Revisé en línea y descubrí que no hay una declaración de eliminación en muchos códigos de creación. ¿Será porque todo el mundo está copiando y pegando? ¿O es causado por tinyxml?

He resumido los siguientes puntos, pero todavía tengo dudas sobre si hay algún problema durante el proceso de desarrollo. Sin embargo, no hay problemas durante el proceso de desarrollo, por lo que mi programa es así por el momento. ser.

Declaración 1: Muchos artículos son de nueva creación y no es necesario eliminarlos, porque tinyxml puede publicar y destruir punteros automáticamente, sin que los desarrolladores necesiten publicarlos manualmente.

Pregunta: ¿Se pueden lanzar nuevos automáticamente? Las nuevas instrucciones se crean en el montón. ¿Cuándo se publicarán automáticamente? ¿Se publicará automáticamente al finalizar el programa? ¿Cómo determinar el final del programa? (Cómo destruir un área de memoria en un módulo en otro módulo, hablaremos de ello más adelante). Entonces este argumento es insostenible.

Dado que tinyxml tiene una función de autodestrucción, verificamos su código fuente y descubrimos que tinyxml liberó el puntero correspondiente en el destructor. Pero no todos los nodos son así.

Detalles en el código fuente:

Copia el código de la siguiente manera:

TiXmlNode::~TiXmlNode()

{

TiXmlNode* nodo = firstChild;

TiXmlNode* temp = 0;

mientras ( nodo )

{

temp = nodo;

nodo = nodo-gt; siguiente;

eliminar temperatura

}

}

}< / p>

void TiXmlNode::Clear()

{

TiXmlNode* nodo = firstChild

TiXmlNode* temp = 0

mientras (nodo)

{

temp = nodo;

nodo = nodo-gt

eliminar; temp ;

}

}

primerhijo = 0;

últimohijo = 0; p >

También sabemos que en tinyxml existe una relación de herencia entre clases.

Así que echemos un vistazo a la clase TixmlElement en tinyxml:

Copia el código de la siguiente manera:

TiXmlElement::~TiXmlElement()

{

Borrar esto()

}

void TiXmlElement::Borrar esto()

{

Borrar();

mientras( atributoSet.First() )

{

TiXmlAttribute* nodo = atributoSet.First();

attributeSet.Remove( nodo );

eliminar nodo

}

}

}

Porque TixmlElement hereda de TiXmlNode, pero el destructor de la clase TiXmlDocument no se puede encontrar en TiXmlDocument.

El segundo parámetro: el objeto TiXmlDocument es el nodo raíz del árbol.

En un documento completo, excepto él, todos los demás nodos deben ser sus descendientes, por lo que TinyXml usa un. Método muy inteligente para destruir el objeto correspondiente a cada nodo----

La tarea de destrucción de cada nodo se delega a su nodo padre. Por lo tanto, si el nodo padre se destruye correctamente, o si se activa la función Clear. del nodo principal, entonces todos sus nodos secundarios se destruirán correctamente.

Por lo tanto, para todo el documento, es suficiente que el objeto TiXmlDocument se destruya correctamente.

En el código creado anteriormente, encontramos que todos los nodos cuelgan debajo del nodo raíz.

De hecho, este código: myDocument-gt; LinkEndChild(RootElement); La relación entre clases es la siguiente:

El código fuente de LinkEndChild es el siguiente: es un método en la clase principal TiXmlNode

Copie el código de la siguiente manera:

TiXmlNode* TiXmlNode::LinkEndChild(TiXmlNode* nodo)

Este código es un método en myDocument-gt;LinkEndChild(RootElement);.

p>{

asertar( nodo-gt; padre == 0 || nodo-gt; padre == esto

asertar( nodo-gt; GetDocument() ==); 0 || nodo-gt; GetDocument() == this-gt; GetDocument()

if ( nodo-gt; Type() == TiXmlNode::DOCUMENT )

{

eliminar nodo;

if ( GetDocument() ) GetDocument()-gt; SetError( nodo-gt; GetDocument() == 0 ||| nodo-gt; GetDocument() == this-gt; GetDocument()) gt;

return 0; >nodo-gt; padre = esto;

nodo-gt; anterior = últimohijo;

nodo-gt; siguiente = 0;

lastChild-gt; next = nodo;

else

firstChild = nodo; // Es una lista vacía.

lastChild = node;

return node;

}

En este caso: simplemente elimine el nodo raíz, que es el programar myDocument en es equivalente a eliminar TiXmlNode, lo que equivale a llamar al destructor de TiXmlNode.

Pregunta: Se dice en Internet que la destrucción de esta forma es desde las hojas hasta las raíces. Según el destructor en TiXmlNode, podemos concluir que se destruye desde la raíz hasta la hoja.

Pero al eliminar myDocument, debemos prestar atención a una cosa:

Cuando creamos el documento (es decir, myDocument en el fragmento del programa), si se crea desde el montón , Necesitamos liberarlo manualmente. Mientras que en el fragmento de programa anterior, se crea en el montón.

TiXmlDocument *myDocument=new TiXmlDocument ();

Si se crea desde el montón, no necesitamos liberarlo manualmente, el programa llamará automáticamente al destructor. También debemos tener en cuenta que se deben crear otros elementos en el montón. Debido a que en el destructor de TiXmlNode, se elimina, pero la pila no se elimina, además del nodo raíz, también se deben crear elementos conectados a los nodos descendientes desde la pila.

Después de nuestra explicación, ¿entiendes el principio de tinyxml? Siempre que comprenda el papel de las clases en tinyxml y la relación entre clases, leer el código fuente no será un problema.

Este blog te aclarará dudas a base de crear una demostración de tinyxml. En el próximo blog, analizaremos xml para responder preguntas de análisis.

El próximo blog se basará en el análisis xml.