Cómo usar tinyxml para manipular xml y prestar atención a los problemas
El formato creado es el siguiente:
El código de copia es el siguiente:
lt;Personsgt
lt;Persongt;
lt;namegt;lhylt;/namegt;
lt;agegt;22lt;/agegt;
lt;/Persongt; p>lt;/ Personsgt;
En el blog anterior, también presentamos todas las clases en el analizador tinyxml y las relaciones entre ellas.
Crea xml en el formato anterior, el código es el siguiente:
Copia el código El código es el siguiente:
//Crea un objeto de documento XML .
TiXmlDocument *myDocument = new TiXmlDocument();
//Crea un elemento raíz y conéctalo.
TiXmlElement *RootElement = new TiXmlElement("Persons");
myDocument-gt; LinkEndChild(RootElement);
//Crea un elemento Persona y conéctate; .
TiXmlElement *PersonElement = new TiXmlElement("Persona");
RootElement-gt; LinkEndChild(PersonElement);
//Crear elemento de nombre y elemento de edad); y conectar.
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 = new TiXmlText("lhy");
TiXmlText *AgeContent = new TiXmlText("22");
NameElement-gt; (NombreContenido);
AgeElement-gt; LinkEndChild(AgeContent);
myDocument-gt; Guardar("d:\\lhy\\xml.txt"); Para archivar
Siempre que comprenda la relación entre nodos en xml, la creación no es un problema. Para decirlo sin rodeos, es una relación de antigüedad.
La creación está hecha, pero como programador de C, después de escribirla, siempre me siento un poco incómodo y algo anda mal. ¿Ves también el sabor a pescado en él?
Por cierto, hay muchos punteros nuevos en algunos códigos. No existe un mecanismo de recolección de basura en Java en C, y usted mismo debe ocuparse de esta basura desechada.
¿Pero no hay ninguna declaración de eliminación en el código?
Revisé la información en línea y descubrí que no hay una declaración de eliminación en muchos códigos de creación. ¿Es porque todo el mundo simplemente copia y pega? ¿O tinyxml está haciendo algo raro?
Resumí los siguientes puntos, pero al final todavía tenía preguntas durante el proceso de desarrollo. Sin embargo, no ocurrieron problemas durante el proceso de desarrollo, por lo que mi programa será como está por el momento.
Declaración 1: En muchos artículos, se usa nuevo sin eliminar, porque tinyxml puede liberar y destruir punteros automáticamente sin la necesidad de que los desarrolladores los liberen manualmente.
Pregunta: ¿Se puede lanzar el nuevo automáticamente? Cuando aparece algo nuevo, significa que se creó en el montón. ¿Cuándo se publicará automáticamente? ¿Se libera automáticamente cuando finaliza el programa? Entonces, ¿cómo juzgar el final del programa? (Cómo destruir el área de memoria en otro módulo en un módulo se discutirá en detalle más adelante), por lo que esta afirmación es contraproducente.
Dado que existe una función de autodestrucción en tinyxml, verificamos su código fuente y descubrimos que es cierto. En el destructor de tinyxml, hay una liberación de puntero correspondiente. 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 = primer hijo;
TiXmlNode* temp = 0
mientras ( nodo )
{
temp = nodo;
nodo = nodo-gt; siguiente;
eliminar temperatura
}
}
void TiXmlNode::Clear()
{
TiXmlNode* nodo = firstChild
TiXmlNode* temp = 0; mientras (nodo)
{
temp = nodo;
nodo = nodo-gt;
eliminar temp; p>
}
firstChild = 0;
lastChild = 0;
}
También sabemos que entre clases en tinyxml Existe una relación de herencia.
Entonces veamos 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( node );
eliminar nodo;
}
}
Porque TixmlElement hereda TiXmlNode pero en TiXmlDocument. no No se encontró el destructor de la clase TiXmlDocument.
La segunda declaración: el objeto TiXmlDocument es el nodo raíz de este árbol.
En un documento completo, excepto él, todos los demás nodos deben ser sus descendientes. Entonces 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 padre, siempre que garantice si el padre se destruye correctamente, o el padre Se llama a la función Clear, todos sus descendientes se destruirán correctamente,
Entonces, para todo el documento, siempre que el objeto TiXmlDocument se destruya correctamente.
En el código creado anteriormente, encontramos que todos los nodos están colgados debajo del nodo raíz.
De hecho, este código: myDocument-gt; LinkEndChild(RootElement); La relación entre clases es la siguiente:
Y el código fuente de LinkEndChild es el siguiente: es un método en la clase padre TiXmlNode
Copia el código de la siguiente manera:
TiXmlNode* TiXmlNode :: LinkEndChild( TiXmlNode* nodo )
{
assert( nodo-gt; padre == 0 || nodo-gt; padre == esto ) ;
assert( nodo-gt; GetDocument() == 0 || nodo-gt; GetDocument() == this-gt; GetDocument()
if (nodo); -gt; Tipo() == TiXmlNode::DOCUMENTO )
{
eliminar nodo
if ( GetDocument() ) GetDocument()-gt; SetError(TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN);
devuelve 0
}
nodo-gt; >nodo-gt; anterior = últimohijo;
nodo-gt; siguiente = 0;
if (últimohijo)
siguiente = nodo;
else
firstChild = node; // era una lista vacía
lastChild = node
return node; p>
}
En este caso: siempre que se elimine el nodo raíz, myDocument en el programa equivale a eliminar TiXmlNode, lo que equivale a llamar al destructor de TiXmlNode.
Pregunta: Se dice en Internet que de esta forma la destrucción es desde las hojas hasta las raíces. Según el destructor en TiXmlNode, podemos concluir que va desde la raíz del árbol hasta las hojas.
Pero cuando eliminamos myDocument, debemos prestar atención a una cosa:
Al crear un documento, es myDocument en el segmento del programa. Si se crea desde el montón, debe liberarse manualmente. Como en nuestro fragmento anterior, se crea en el montón.
TiXmlDocument *myDocument=new TiXmlDocument ();
Si se crea desde la pila, no necesitamos liberarlo manualmente, pero el programa llama automáticamente al destructor. Al mismo tiempo debemos tener en cuenta que se deben crear otros elementos en el montón. Porque en el destructor TiXmlNode, se elimina, pero no es necesario eliminar el contenido de la pila, por lo que los nodos descendientes conectados, excepto el nodo raíz, deben crearse desde el montón.
Después de nuestra explicación, ¿entiendes los principios de tinyxml? Siempre que comprenda el papel de las clases en tinyxml y la relación entre clases, no tendrá problemas para leer el código fuente.
Este blog explica las dudas existentes a partir de la creación de una pequeña demo xml. En el próximo blog, responderemos preguntas sobre el análisis basado en el análisis xml.