tinyxml2源码分析-2

最新推荐文章于 2023-05-12 16:09:43 发布
最新推荐文章于 2023-05-12 16:09:43 发布
阅读量1.1k 收藏 3
点赞数 4
分类专栏： tinyxml2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiukongjian/article/details/52663946
版权 


</pre><p>为避免对std::string的依赖，自己编写一个StrPair，如下(这不是主代码，直接上最终代码)：</p><p></p><pre name="code" class="cpp">class StrPair
{
public:
    enum {
        NEEDS_ENTITY_PROCESSING			= 0x01,
        NEEDS_NEWLINE_NORMALIZATION		= 0x02,
        NEEDS_WHITESPACE_COLLAPSING     = 0x04,

        TEXT_ELEMENT		            = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
        TEXT_ELEMENT_LEAVE_ENTITIES		= NEEDS_NEWLINE_NORMALIZATION,
        ATTRIBUTE_NAME		            = 0,
        ATTRIBUTE_VALUE		            = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
        ATTRIBUTE_VALUE_LEAVE_ENTITIES  = NEEDS_NEWLINE_NORMALIZATION,
        COMMENT							= NEEDS_NEWLINE_NORMALIZATION
    };

    StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
    ~StrPair();

    void Set( char* start, char* end, int flags ) {
        TIXMLASSERT( start );
        TIXMLASSERT( end );
        Reset();
        _start  = start;
        _end    = end;
        _flags  = flags | NEEDS_FLUSH;
    }

    const char* GetStr();

    bool Empty() const {
        return _start == _end;
    }

    void SetInternedStr( const char* str ) {
        Reset();
        _start = const_cast<char*>(str);
    }

    void SetStr( const char* str, int flags=0 );

    char* ParseText( char* in, const char* endTag, int strFlags );
    char* ParseName( char* in );

    void TransferTo( StrPair* other );
	void Reset();

private:
    void CollapseWhitespace();

    enum {
        NEEDS_FLUSH = 0x100,
        NEEDS_DELETE = 0x200
    };

    int     _flags;
    char*   _start;
    char*   _end;

    StrPair( const StrPair& other );	// not supported
    void operator=( StrPair& other );	// not supported, use TransferTo()
};

代码很容易读懂，一个ｓｔｒｉｎｇ类的基本要求，构造，ｓｅｔ，ｇｅｔ，但是禁止了拷贝，而使用函数ＴｒａｎｓｆｅｒＴｏ。有点费解的是_flag成员变量，StrPair的持有的指针有些情况是不需要delete，这就是枚举NEEDS_DELETE,NEDDS_FLUSH的来源,所有的标志亮是bit定义，所以操作flag的时候位操作。

Reset:

void StrPair::Reset()
{
    if ( _flags & NEEDS_DELETE ) {
        delete [] _start;
    }
    _flags = 0;
    _start = 0;
    _end = 0;
}

SetStr:先调用Reset，将原来的字符串释放(是NEEDS_DELETE类型)，调用strlen获取长度，分配内存并拷贝，将标志置为NEEDS_DELETE。

void StrPair::SetStr( const char* str, int flags )
{
    TIXMLASSERT( str );
    Reset();
    size_t len = strlen( str );
    TIXMLASSERT( _start == 0 );
    _start = new char[ len+1 ];
    memcpy( _start, str, len+1 );
    _end = _start + len;
    _flags = flags | NEEDS_DELETE;
}

ParseText: 所谓的ParseText，其实就是个find，找到相等字符串后，设置标志

char* StrPair::ParseText( char* p, const char* endTag, int strFlags )
{
    TIXMLASSERT( endTag && *endTag );

    char* start = p;
    char  endChar = *endTag;
    size_t length = strlen( endTag );

    // Inner loop of text parsing.
    while ( *p ) {
        if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {
            Set( start, p, strFlags );
            return p + length;
        }
        ++p;
    }
    return 0;
}
IsNameStartChar: 
    inline static bool IsNameStartChar( unsigned char ch ) {
        if ( ch >= 128 ) {
            // This is a heuristic guess in attempt to not implement Unicode-aware isalpha()
            return true;
        }
        if ( isalpha( ch ) ) {
            return true;
        }
        return ch == ':' || ch == '_';
    }

IsNameChar:

    inline static bool IsNameChar( unsigned char ch ) {
        return IsNameStartChar( ch )
               || isdigit( ch )
               || ch == '.'
               || ch == '-';
    }

ParseName:搜索名称

char* StrPair::ParseName( char* p )
{
    if ( !p || !(*p) ) {
        return 0;
    }
    if ( !XMLUtil::IsNameStartChar( *p ) ) {
        return 0;
    }

    char* const start = p;
    ++p;
    while ( *p && XMLUtil::IsNameChar( *p ) ) {
        ++p;
    }

    Set( start, p, 0 );
    return p;
}
CollapseWhitespace:就是把多余的空格合并为一个... 
void StrPair::CollapseWhitespace()
{
    // Adjusting _start would cause undefined behavior on delete[]
    TIXMLASSERT( ( _flags & NEEDS_DELETE ) == 0 );
    // Trim leading space.
    _start = XMLUtil::SkipWhiteSpace( _start );

    if ( *_start ) {
        const char* p = _start;	// the read pointer
        char* q = _start;	// the write pointer

        while( *p ) {
            if ( XMLUtil::IsWhiteSpace( *p )) {
                p = XMLUtil::SkipWhiteSpace( p );
                if ( *p == 0 ) {
                    break;    // don't write to q; this trims the trailing space.
                }
                *q = ' ';
                ++q;
            }
            *q = *p;
            ++q;
            ++p;
        }
        *q = 0;
    }
}
GetStr:NEEDS_FLUSH,就是字符串结尾需要赋值null，并根据不同的标志，处理字符串，处理xml转义字符。 

const char* StrPair::GetStr()
{
    TIXMLASSERT( _start );
    TIXMLASSERT( _end );
    if ( _flags & NEEDS_FLUSH ) {
        *_end = 0;
        _flags ^= NEEDS_FLUSH;//清除标记

        if ( _flags ) {
            const char* p = _start;	// the read pointer
            char* q = _start;	// the write pointer

            while( p < _end ) {
                if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) {
                    if ( *(p+1) == LF ) {
                        p += 2;<span style="font-family: Arial, Helvetica, sans-serif;">// \r\n 替换为\n</span>
                    }
                    else {
                        ++p;<span style="font-family: Arial, Helvetica, sans-serif;">// </span><span style="font-family: Arial, Helvetica, sans-serif;">\r</span><span style="font-family: Arial, Helvetica, sans-serif;"> </span><span style="font-family: Arial, Helvetica, sans-serif;">替换为\n</span>
                    }
                    *q++ = LF;
                }
                else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {
                    if ( *(p+1) == CR ) {//\n\r替换为\n
                        p += 2;
                    }
                    else {
                        ++p;
                    }
                    *q++ = LF;
                }
<span>		</span>//对&#dddd;类型的unicode转义
                else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {
                    if ( *(p+1) == '#' ) {
                        const int buflen = 10;
                        char buf[buflen] = { 0 };
                        int len = 0;
                        char* adjusted = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );
                        if ( adjusted == 0 ) {
                            *q = *p;
                            ++p;
                            ++q;
                        }
                        else {
                            TIXMLASSERT( 0 <= len && len <= buflen );
                            TIXMLASSERT( q + len <= adjusted );
                            p = adjusted;
                            memcpy( q, buf, len );
                            q += len;
                        }
                    }
                    else {
                        bool entityFound = false;//循环遍历转义字符全局变量，如果字符串相等，则转义
                        for( int i = 0; i < NUM_ENTITIES; ++i ) {
                            const Entity& entity = entities[i];
                            if ( strncmp( p + 1, entity.pattern, entity.length ) == 0
                                    && *( p + entity.length + 1 ) == ';' ) {
                                // Found an entity - convert.
                                *q = entity.value;
                                ++q;
                                p += entity.length + 2;
                                entityFound = true;
                                break;
                            }
                        }
                        if ( !entityFound ) {
                            // fixme: treat as error?找不到转义字符，继续
                            ++p;
                            ++q;
                        }
                    }
                }
                else {
                    *q = *p;
                    ++p;
                    ++q;
                }
            }
            *q = 0;
        }
        // The loop below has plenty going on, and this
        // is a less useful mode. Break it out.
        if ( _flags & NEEDS_WHITESPACE_COLLAPSING ) {
            CollapseWhitespace();
        }
        _flags = (_flags & NEEDS_DELETE);
    }
    TIXMLASSERT( _start );
    return _start;
}
entities是转义字符定义 

struct Entity {
    const char* pattern;
    int length;
    char value;
};
static const int NUM_ENTITIES = 5;
static const Entity entities[NUM_ENTITIES] = {
    { "quot", 4,	DOUBLE_QUOTE },
    { "amp", 3,		'&'  },
    { "apos", 4,	SINGLE_QUOTE },
    { "lt",	2, 		'<'	 },
    { "gt",	2,		'>'	 }
};


在我们实现其他子类时，先考虑一下内存分配，内存池，我们先定义内存池接口：

class MemPool
{
public:
	MemPool() {}
	virtual ~MemPool() {}
	virtual int ItemSize() const = 0;
	virtual void* Alloc() = 0;
	virtual void Free(void*) = 0;
	virtual void SetTracked() = 0;
	virtual void Clear() = 0;
};
接下来是内存池放在哪里，毫无悬念，只能放在XMLDocument，因为对于一个xml文件，只有一个XMLDocument。既然这样，我们先定义ＸＭＬＤｏｃｕｍｅｎｔ，读取文件，我们放在后续编写，先保留接口。先实现向下转型，定义RootElement，然后就是各个节点的New函数。抛开ＭｅｍＰｏｏｌＴ是对ＭｅｍＰｏｏｌ的实现，后面会分析其代码， 

class XMLDocument : public XMLNode
{
	friend class XMLElement;
public:
	/// constructor
	XMLDocument(bool processEntities = true, Whitespace = PRESERVE_WHITESPACE);
	~XMLDocument();

	virtual XMLDocument* ToDocument()				{
		TIXMLASSERT(this == _document);
		return this;
	}
	virtual const XMLDocument* ToDocument() const	{
		TIXMLASSERT(this == _document);
		return this;
	}

	XMLError LoadFile(const char* filename);

	XMLError SaveFile(const char* filename, bool compact = false);

	XMLElement* RootElement()				{
		return FirstChildElement();
	}
	const XMLElement* RootElement() const	{
		return FirstChildElement();
	}

	XMLElement* NewElement(const char* name);

	XMLComment* NewComment(const char* comment);

	XMLText* NewText(const char* text);

	XMLDeclaration* NewDeclaration(const char* text = 0);

	XMLUnknown* NewUnknown(const char* text);

	void DeleteNode(XMLNode* node);
	/// Clear the document, resetting it to the initial state.
	void Clear();
private:
	XMLDocument(const XMLDocument&);	// not supported
	void operator=(const XMLDocument&);	// not supported
	XMLError    _errorID;
	MemPoolT< sizeof(XMLElement) >	 _elementPool;
	MemPoolT< sizeof(XMLAttribute) > _attributePool;
	MemPoolT< sizeof(XMLText) >		 _textPool;
	MemPoolT< sizeof(XMLComment) >	 _commentPool;
};

接下来我们实现XMLText

class XMLText : public XMLNode
{
	friend class XMLDocument;
public:
	virtual XMLText* ToText(){
		return this;
	}
	virtual const XMLText* ToText() const{
		return this;
	}
	/// Declare whether this should be CDATA or standard text.
	void SetCData(bool isCData)	{
		_isCData = isCData;
	}
	/// Returns true if this is a CDATA text element.
	bool CData() const{
		return _isCData;
	}
protected:
	XMLText(XMLDocument* doc) : XMLNode(doc), _isCData(false){
	}
	virtual ~XMLText(){
	}
private:
	bool _isCData;
	XMLText(const XMLText&);	// not supported
	XMLText& operator=(const XMLText&);	// not supported
};

首先实现向下转型函数，XMLText有两种类型，一种是CData类型，一种是普通类型，这里需要一个标志来区分_isCData，所以有SetCData和CData接口。这里构造函数仍为protected，是因为该类型需要在XMLDocument中new出来。好像少了Text内容，这时候我们是不是应该增加一个成员变量来实现呢，比如std::string _strValue;考虑到所有子类都有自己的内容，所以把内容放在基类，

给ＸＭＬＮｏｄｅ增加ｐｒｏｔｅｃｔｅｄ成员变量，和相关接口函数。Value的意义对不同的元素是不同的，具体如下

     Document:空(返回NULL，而不是空字符串)
    Element: Elment的名字
    Comment: 注释文字
    Unknown: the tag contents
    Text: 文本

mutable StrPair	_value;
    const char* Value() const;
    void SetValue( const char* val, bool staticMem=false );
接下来的似乎不言而喻的 

class XMLComment : public XMLNode
{
	friend class XMLDocument;
public:
	virtual XMLComment*	ToComment()					{
		return this;
	}
	virtual const XMLComment* ToComment() const		{
		return this;
	}
protected:
	XMLComment(XMLDocument* doc);
	virtual ~XMLComment();
private:
	XMLComment(const XMLComment&);	// not supported
	XMLComment& operator=(const XMLComment&);	// not supported
};
class XMLDeclaration : public XMLNode
{
	friend class XMLDocument;
public:
	virtual XMLDeclaration*	ToDeclaration()					{
		return this;
	}
	virtual const XMLDeclaration* ToDeclaration() const		{
		return this;
	}
protected:
	XMLDeclaration(XMLDocument* doc);
	virtual ~XMLDeclaration();
private:
	XMLDeclaration(const XMLDeclaration&);	// not supported
	XMLDeclaration& operator=(const XMLDeclaration&);	// not supported
};

class XMLUnknown : public XMLNode
{
	friend class XMLDocument;
public:
	virtual XMLUnknown*	ToUnknown()					{
		return this;
	}
	virtual const XMLUnknown* ToUnknown() const		{
		return this;
	}
protected:
	XMLUnknown(XMLDocument* doc);
	virtual ~XMLUnknown();
private:
	XMLUnknown(const XMLUnknown&);	// not supported
	XMLUnknown& operator=(const XMLUnknown&);	// not supported
};
在编写ＸＭＬＥｌｅｍｅｎｔ前，首先编写ＸＭＬＡｔｔｒｉｂｕｔｅ： 

class XMLAttribute
{
	friend class XMLElement;
public:
	/// The name of the attribute.
	const char* Name() const;

	/// The value of the attribute.
	const char* Value() const;

	/// The next attribute in the list.
	const XMLAttribute* Next() const {
		return _next;
	}
	void SetAttribute(const char* value);
private:
	enum { BUF_SIZE = 200 };

	XMLAttribute() : _next(0), _memPool(0) {}
	virtual ~XMLAttribute()	{}
	XMLAttribute(const XMLAttribute&);	// not supported
	void operator=(const XMLAttribute&);	// not supported
	void SetName(const char* name);
	mutable StrPair _name;
	mutable StrPair _value;
	XMLAttribute*   _next;
	MemPool*        _memPool;
};
所谓的Ａｔｔｒｉｂｕｔｅ其实就是个ｋｅｙ，ｖａｌｕｅ对。而Ａｔｔｒｉｂｕｔｅ还要实现单向链表，这样只要在Ｅｌｅｍｅｎｔ中有首属性，就可以通过＿ｎｅｘｔ来遍历属性。Ａｔｔｒｉｂｕｔｅ只能由Document来创建。 

class XMLElement : public XMLNode
{
	friend class XMLDocument;
public:
	/// Get the name of an element (which is the Value() of the node.)
	const char* Name() const		{
		return Value();
	}
	/// Set the name of the element.
	void SetName(const char* str, bool staticMem = false)	{
		SetValue(str, staticMem);
	}

	virtual XMLElement* ToElement()				{
		return this;
	}
	virtual const XMLElement* ToElement() const {
		return this;
	}

	const char* Attribute(const char* name, const char* value = 0) const;

	/// Sets the named attribute to value.
	void SetAttribute(const char* name, const char* value)	{
		XMLAttribute* a = FindOrCreateAttribute(name);
		a->SetAttribute(value);
	}

	/**
	Delete an attribute.
	*/
	void DeleteAttribute(const char* name);

	/// Return the first attribute in the list.
	const XMLAttribute* FirstAttribute() const {
		return _rootAttribute;
	}
	/// Query a specific attribute in the list.
	const XMLAttribute* FindAttribute(const char* name) const;
	const char* GetText() const;
	void SetText(const char* inText);
private:
	XMLElement(XMLDocument* doc);
	virtual ~XMLElement();
	XMLElement(const XMLElement&);	// not supported
	void operator=(const XMLElement&);	// not supported

	XMLAttribute* FindAttribute(const char* name) {
		return const_cast<XMLAttribute*>(const_cast<const XMLElement*>(this)->FindAttribute(name));
	}
	XMLAttribute* FindOrCreateAttribute(const char* name);

	static void DeleteAttribute(XMLAttribute* attribute);

	// The attribute list is ordered; there is no 'lastAttribute'
	// because the list needs to be scanned for dupes before adding
	// a new attribute.
	XMLAttribute* _rootAttribute;
};
Attribute: 
const char* XMLElement::Attribute( const char* name, const char* value ) const
{
    const XMLAttribute* a = FindAttribute( name );
    if ( !a ) {
        return 0;
    }
    if ( !value || XMLUtil::StringEqual( a->Value(), value )) {
        return a->Value();
    }
    return 0;
}

查找name Attribute,若果输入的value非空，则需要比较name 和value,都不能匹配则返回0。

FindAttribute:

const XMLAttribute* XMLElement::FindAttribute( const char* name ) const
{
    for( XMLAttribute* a = _rootAttribute; a; a = a->_next ) {
        if ( XMLUtil::StringEqual( a->Name(), name ) ) {
            return a;
        }
    }
    return 0;
}
遍历单向列表，也没什么说的。

GetText:从代码说明一切，Element的text属性，要求它第一个子节点必须为XMLText。

const char* XMLElement::GetText() const
{
    if ( FirstChild() && FirstChild()->ToText() ) {
        return FirstChild()->Value();
    }
    return 0;
}
SetText:注意NewText，内存由Document来分配 
void	XMLElement::SetText(const char* inText)
{
	if (FirstChild() && FirstChild()->ToText())
		FirstChild()->SetValue(inText);
	else {
		XMLText*	theText = GetDocument()->NewText(inText);
		InsertFirstChild(theText);
	}
}

FindOrCreateAttribute：遍历链表查找Attribute,如果找不到，则调用Document的内存池分配内存，定位new，并将该Attribute添加到链表尾。

XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
{
    XMLAttribute* last = 0;
    XMLAttribute* attrib = 0;
    for( attrib = _rootAttribute;
            attrib;
            last = attrib, attrib = attrib->_next ) {
        if ( XMLUtil::StringEqual( attrib->Name(), name ) ) {
            break;
        }
    }
    if ( !attrib ) {
        TIXMLASSERT( sizeof( XMLAttribute ) == _document->_attributePool.ItemSize() );
        attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
        attrib->_memPool = &_document->_attributePool;
        if ( last ) {
            last->_next = attrib;
        }
        else {
            _rootAttribute = attrib;
        }
        attrib->SetName( name );
        attrib->_memPool->SetTracked(); // always created and linked.
    }
    return attrib;
}

DeleteAttribute:单向链表删除某个节点，首先遍历比较，如果name相等则断开链接，并在内存池中删除内存

void XMLElement::DeleteAttribute( const char* name )
{
    XMLAttribute* prev = 0;
    for( XMLAttribute* a=_rootAttribute; a; a=a->_next ) {
        if ( XMLUtil::StringEqual( name, a->Name() ) ) {
            if ( prev ) {
                prev->_next = a->_next;
            }
            else {
                _rootAttribute = a->_next;
            }
            DeleteAttribute( a );
            break;
        }
        prev = a;
    }
}
删除XMLAttribute的内存，因为使用的是定位new，所以主动调用析构函数。 

void XMLElement::DeleteAttribute(XMLAttribute* attribute)
{
	if (attribute == 0) {
		return;
	}
	MemPool* pool = attribute->_memPool;
	attribute->~XMLAttribute();
	pool->Free(attribute);
}
FindAttribute：前面已经分析过类似的了 
const XMLAttribute* XMLElement::FindAttribute(const char* name) const
{
	for (XMLAttribute* a = _rootAttribute; a; a = a->_next) {
		if (XMLUtil::StringEqual(a->Name(), name)) {
			return a;
		}
	}
	return 0;
}
至此，我们基本编写完毕各个子类的代码。现在来看，各个ＸＭＬＮｏｄｅ的子类，只有ＸＭＬＤｏｃｕｍｅｎｔ的构造函数是ｐｕｂｌｉｃ，其他的子类只能通过ＸＭＬＤｏｃｕｍｅｎｔ来ｎｅｗ，而ＸＭＬＤｏｃｕｍｅｎｔ持有各个元素的内存池，包括ＸＭＬＡｔｔｒｉｂｕｔｅ，这样只要ＸＭＬＤｏｃｕｍｅｎｔ没用析构，所有元素的指针都是有效的。

走调的鱼
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
tinyxml2 源码分析（二）
ml143的专栏
03-28 729
tinyxml源码分析（二）主要分析XMLPrinter的实现和内存管理。
tinyxml2源码分析（一）
ml143的专栏
03-26 2221
tinyxml2源码分析（一）主要分析文本解析部分
tinyxml2源码及示例
10-13
适用于桌面系统和移动系统tinyxml2
TinyXML2源代码及工程
12-22
TinyXML2源代码及工程，读写轻便有效率，接口易使用
tinyxml2源码分析-1
09-25 1123
换一种方式来对源码分析，从零开始“写”一个tinyxml2。提前郑重声明，本博客所有大tinyxml代码都直接copy自tinyxml源码。 在开始分析源码前，如下图所示，是tinyxml2的各个主要类型，XMLAttribute其实是一个单向链表，放在后面实现。 tinyxml2把xml文档建立成一棵DOM树，具体实现用的是firstchild–nextsiblingtree，如
tinyXml2源码
09-21
tinyXml2源码，方便以后下载,mark
Tinyxml解析源码
08-18
TinyXML的源码分析可以从以下几个方面入手： 1. **解析流程**：TinyXML通过`TiXmlDocument`类作为入口，加载XML文件。它首先读取文件内容，然后通过`TiXmlElement`类解析XML元素，`TiXmlAttribute`处理属性，`...
yolov4-tiny火焰检测源码
09-14
《YOLOv4-tiny火焰检测源码解析与应用》 YOLO（You Only Look Once）是一种基于深度学习的目标检测框架，因其实时性高、准确率优秀而广受青睐。YOLOv4-tiny是YOLO系列的一个轻量级版本，优化了计算效率，适合在资源...
tinyxml解析工具修复内存泄漏
05-06
这个tinyxml是在部门产品应用过程中发现存在内存泄漏的问题，通过代码分析，解决了在xml使用结束时，内存清理不彻底而导致的内存泄漏问题。电驴源码中使用的tinyxml也存在这个问题。不知最新版有没有修复。
C++ —— Tinyxml2在Vs2017下相关使用1（附源码）
wx微信公众号“码农总动员”，获取更多编程知识
05-12 330
TinyXML2是一个简单，小巧，高效，C++XML解析器，可以很容易地集成到其他程序中。TinyXML-2解析一个XML文档，并从中构建一个 可以读取、修改和保存的文档对象模型 （DOM）。XML代表“可扩展标记语言”。这是一个通用目的 用于描述任意数据的人类和机器可读标记语言。为存储应用程序数据而创建的所有随机文件格式都可以 全部替换为 XML。一个解析器可以解决所有问题。
TinyXML-2(XML解析)
01-24
TinyXML2比1精简多了，只有2个文件。官方项目地址是：https://github.com/leethomason/tinyxml2
tinyxml2+示例代码+介绍文档
09-26
资源包含2015.9.23从官网下载的tinyxml2的源码和自己编写的示例代码还有介绍文档，容易上手。官网的示例代码和文档晦涩难懂，才自己整理。
tinyxml源代码，示例，教程
03-25
便宜，超全 快速入门 tinyxml源代码，示例，教程 三个包
tinyxml2最新版本（来自github）
08-17
tinyxml2最新版本__20170817 （来自github）
tinyxml2.rar
12-27
tinyXml库
TinyXML2
tianzhiyi1989sq的博客
02-26 380
记录xml文件的读取，解析与保存 tinyxml2源码如下链接 tinyxml2 xml文件结构 // xml文件的生成 //------------ //声明要创建的xml文件 //------------ tinyxml2::XMLDocument xml; tinyxml2::XMLDeclaration* declaration = xml.NewDeclaration(); xml.InsertFirstChild(declaration); //------------ //
tinyxml2源码分析-3
09-26 982
有了所有的子节点，可以开始编写LoadFile的代码了,XMLError是个枚举类型，一般而言，先定义一个枚举，同时定义XML_SUCCESS=0，因为成功不需要理由，失败者总是需要借口。等到编码到后期再添加错误码。 XMLError XMLDocument::LoadFile( const char* filename ) { Clear(); FILE* fp = cal
tinyxml2源码分析-4
09-28 755
接下来分析写文件，这个简单，使用visitor设计模式来实现，visitor接口如下，注意Element的visit接口，传入了XMLAttribute指针 来遍历Attribute class XMLVisitor { public: virtual ~XMLVisitor() {} /// Visit a document. virtual bool VisitEn
TinyXML2.rar
03-14
C++轻量XML文件解析库！用于C++项目中进行XML文件的读取和创建！使用方法见本人blog！
tinyxml2 源码分析
最新发布
06-03
tinyxml2 是一个轻量级的 C++ XML 解析库，它提供了一个简单的 API，用于解析、修改和创建 XML 文档。下面是对 tinyxml2 源码的一些分析： 1. 文件结构 tinyxml2 的源码包括以下文件： - tinyxml2.h：包含 tinyxml2 的 API。 - tinyxml2.cpp：包含 tinyxml2 的实现代码。 - xmltest.cpp：包含 tinyxml2 的测试代码。 2. 类结构 tinyxml2 基于 DOM（文档对象模型）模式，它将 XML 文档表示为一棵树。以下是 tinyxml2 的主要类： - XMLDocument：表示整个 XML 文档，包括所有元素、属性和文本。 - XMLElement：表示 XML 文档中的元素，包括其标签名、属性和子元素。 - XMLAttribute：表示 XML 元素的属性。 - XMLText：表示 XML 元素中的文本。 3. 解析流程 tinyxml2 的解析流程是基于事件的，它将 XML 文档分为不同的事件，如元素开始、元素结束、文本等。解析器从头到尾扫描 XML 文档，当它遇到一个事件时，它会调用相应的回调函数。 以下是 tinyxml2 的解析流程： - 创建一个 XMLDocument 对象。 - 调用 XMLDocument::LoadFile() 或 XMLDocument::Parse() 方法，将 XML 文档加载到内存中。 - 解析器开始扫描 XML 文档，并调用相应的回调函数处理每个事件。 - 解析器将事件转换为节点，将节点添加到 XMLDocument 对象中。 - 解析器返回 XMLDocument 对象，表示解析完成。 4. 修改流程 tinyxml2 允许修改 XML 文档，包括添加、删除、修改元素和属性等。以下是 tinyxml2 的修改流程： - 创建一个 XMLDocument 对象。 - 调用 XMLDocument::LoadFile() 或 XMLDocument::Parse() 方法，将 XML 文档加载到内存中。 - 使用 tinyxml2 的 API 修改 XMLDocument 对象。 - 调用 XMLDocument::SaveFile() 方法，将修改后的 XML 文档保存到磁盘。 总之，tinyxml2 是一个非常简单、易于使用的 XML 解析库，它可以轻松处理 XML 文档的解析和修改。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值