C++使用TinyXML

参照一:http://qaohao.iteye.com/blog/496237

参照二:http://hi.baidu.com/lnylvoeegzcgnrr/item/af68fd9cde40fc1a924f41f5

别人封装的TinyXML：

.h文件

 #include "xml\tinyxml.h"
 #include <string>
 using namespace std;

 #if !defined(AFX_STDAFX_H__UDXML_EF91_4EF1_A2F2_53AD89B23C30__INCLUDED_)
 #define AFX_STDAFX_H__UDXML_EF91_4EF1_A2F2_53AD89B23C30__INCLUDED_

 #if _MSC_VER > 1000
 #pragma once
 #endif 

 /******************************************************************************
   描述: 对tinyxml库封装的简单类:
         1,创建、保存xml
         2,动态创建节点，更改名称以及值；动态删除
         3,动态增加、删除属性，遍历、读取属性名称以及值

   背景: tinyxml对xml操作的接口过于分散，为了适应自己的需要，对常用的接口进行简单的封
         装，各个接口增加注释，方便使用。

   环境: WinXP+VC6
   修改: 仇军利        EMAIL:282881515@163.COM        QQ:282881515
   版本: 2012-12-28    V1.0
   发布: CSDN
 ******************************************************************************/
 class CUDXmlAttribute
 {
 public:
     CUDXmlAttribute()                           { m_pAttribute=NULL      ; }
     CUDXmlAttribute( TiXmlAttribute *pAttribute){ m_pAttribute=pAttribute; }

     //              下一个属性
     CUDXmlAttribute Next();
     //              前一个属性
     CUDXmlAttribute Pre();

     //              返回属性名称
     string          Name();
     //              设置属性名称
     void            SetName(const char* name);

     //              返回属性值string类型
     string          Value();
     //              返回属性值int类型
     int             IntValue();
     //              返回属性值double类型
     double          DoubleValue();
     //              设置属性值
     void            SetValue(const char* value);  

 private:
     TiXmlAttribute *m_pAttribute;
 };

 class CUDXmlNodePtr
 {
 public:
     CUDXmlNodePtr()                         { m_pElement=NULL; }
     CUDXmlNodePtr(TiXmlElement *pElement)   { m_pElement=pElement; }
     CUDXmlNodePtr(TiXmlNode* pNode)         { m_pElement=pNode->ToElement(); }
     BOOL          operator==(CUDXmlNodePtr&node);

     //              添加新的节点
     CUDXmlNodePtr   NewChild(const char* name);
     //              获取第一个孩子节点，默认返回第一个孩子节点
     CUDXmlNodePtr   GetFirstChild(const char* name=NULL);
     //              获取下一个兄弟节点，默认返回下边第一个兄弟节点
     CUDXmlNodePtr   NextSibling(const char* name=NULL);
     //              获取上一个兄弟节点，默认返回上边第一个兄弟节点
     CUDXmlNodePtr   PreSibling(const char* name=NULL);
     //              自我销毁
     BOOL            Destory();
     //              销毁所有孩子节点
     void            DestoryAllChildren();

     //              设置属性
     void            SetAttribute(const char* name, const char* value);
     //              读取属性值
     string          GetAttribute(const char* name);
     CUDXmlAttribute GetFirstAttribute();
     CUDXmlAttribute LastAttribute();

     //              设置节点名称
     void            SetName(const char*name);
     //              获取节点名称
     string          GetName();

     //              设置节点值
     void            SetValue(const char* value);
     //              获取节点值
     string          GetValue();

     //              判断该节点是否为空
     BOOL            IsNull();
     //              返回根节点
     CUDXmlNodePtr   Root();

 public:
     TiXmlElement *m_pElement;
 };

 class CUDXml
 {
 public:
     //    创建xml文件 默认声明为<?xml version="1.0" encoding="UTF-8" standalone="no"?>
     BOOL  CreateXml(const char* path, const char* version="1.0", const char*  encoding="UTF-8", const char*  standalone="no");

     //    打开文件
     BOOL  Open(const char* path);

     //    保存文件
     BOOL  Save(const char* path=NULL);

     //    获取根节点
     CUDXmlNodePtr  GetRoot();

     //    判断该文件是否存在
     BOOL  IsExist(const char* path);

 private:

     TiXmlDocument m_doc;
 };
 #endif 

.cpp文件

 #include <windows.h>
 #include <stdio.h>
 #include <tchar.h>
 #include "UDXml.h"
 #include <io.h>

 BOOL CUDXml::CreateXml(const char*  path,  const char* _version /*="1.0" */, const char* _encoding /*="UTF-8" */, const char* _standalone/*="no" */ )
 {
     m_doc.LoadFile(path, TIXML_ENCODING_UTF8);

     TiXmlNode *pDelar = new TiXmlDeclaration(_version, _encoding, _standalone);
     m_doc.InsertEndChild(*pDelar);delete pDelar;

     TiXmlNode *pRoot  = new TiXmlElement("root");
     m_doc.InsertEndChild(*pRoot);    

     return TRUE;
 }

 BOOL CUDXml::Open( const char* path )
 {
     return m_doc.LoadFile(path, TIXML_ENCODING_UTF8);
 }

 BOOL CUDXml::Save(const char* path)
 {
     BOOL ret;

     if(NULL == path) ret = m_doc.SaveFile();
     else ret = m_doc.SaveFile(path);

     return ret;
 }

 CUDXmlNodePtr  CUDXml::GetRoot()
 {
     return m_doc.RootElement();
 }

 BOOL CUDXml::IsExist( const char* path )
 {
     if(- != _access(path, ))
         return TRUE;
     else
         return FALSE;
 }

 CUDXmlNodePtr CUDXmlNodePtr::NewChild( const char* name )
 {
     CUDXmlNodePtr NewNode;
     TiXmlNode *pNode = new TiXmlElement(name);

     NewNode = m_pElement->InsertEndChild(*pNode);

     delete pNode;
     return NewNode;
 }

 BOOL CUDXmlNodePtr::IsNull()
 {
     return NULL==m_pElement;
 }

 void CUDXmlNodePtr::SetAttribute( const char* name, const char* value )
 {
     m_pElement->SetAttribute(name, value);
 }

 std::string CUDXmlNodePtr::GetAttribute( const char* name )
 {
     return     m_pElement->Attribute(name);
 }

 void CUDXmlNodePtr::SetName( const char*name )
 {
     m_pElement->SetValue(name);
 }

 std::string CUDXmlNodePtr::GetName()
 {
     const char *pName = m_pElement->Value();
     if(NULL == pName)
         return "";

     return pName;
 }    

 void CUDXmlNodePtr::SetValue( const char* value )
 {
     TiXmlNode *pText = new TiXmlText(value);
     m_pElement->InsertEndChild(*pText);
     delete pText;
 }

 std::string CUDXmlNodePtr::GetValue()
 {
     const char* pText = m_pElement->GetText();
     if(NULL == pText)
         return "";

     return pText;
 }

 CUDXmlNodePtr CUDXmlNodePtr::GetFirstChild( const char* name/*=NULL*/ )
 {
     if(NULL == name)
         return m_pElement->FirstChildElement();
     else
         return m_pElement->FirstChildElement(name);
 }

 CUDXmlNodePtr CUDXmlNodePtr::NextSibling( const char* name/*=NULL*/ )
 {
     if(NULL == name)
         return m_pElement->NextSiblingElement();
     else
         return m_pElement->NextSiblingElement(name);
 }

 CUDXmlNodePtr CUDXmlNodePtr::PreSibling( const char* name/*=NULL*/ )
 {
     if(NULL == name)
         return m_pElement->PreviousSibling();
     else
         return m_pElement->PreviousSibling(name);
 }

 BOOL CUDXmlNodePtr::Destory()
 {
     if(*this == Root())return FALSE;

     return    m_pElement->Parent()->RemoveChild((TiXmlNode*)m_pElement);
 }

 CUDXmlNodePtr CUDXmlNodePtr::Root()
 {
     TiXmlElement *pElement = m_pElement;
     TiXmlElement *pRoot = NULL;

     int nType = pElement->Type();
     while ( != nType)
     {
         pRoot    = pElement;
         pElement = (TiXmlElement*)pElement->Parent();
         nType    = pElement->Type();
     }

     return pRoot;
 }

 BOOL CUDXmlNodePtr::operator==( CUDXmlNodePtr&node )
 {
     return this->m_pElement == node.m_pElement;
 }

 void CUDXmlNodePtr::DestoryAllChildren()
 {
     m_pElement->Clear();
 }

 CUDXmlAttribute CUDXmlNodePtr::GetFirstAttribute()
 {
     return m_pElement->FirstAttribute();
 }

 CUDXmlAttribute CUDXmlNodePtr::LastAttribute()
 {
     return m_pElement->LastAttribute();
 }

 CUDXmlAttribute CUDXmlAttribute::Next()
 {
     return    m_pAttribute->Next();
 }

 CUDXmlAttribute CUDXmlAttribute::Pre()
 {
     return m_pAttribute->Previous();
 }

 std::string CUDXmlAttribute::Name()
 {
     return m_pAttribute->Name();
 }

 std::string CUDXmlAttribute::Value()
 {
     return m_pAttribute->Value();
 }

 void CUDXmlAttribute::SetName( const char* name )
 {
     m_pAttribute->SetName(name);
 }

 void CUDXmlAttribute::SetValue( const char* value )
 {
     m_pAttribute->SetValue(value);
 }

 double CUDXmlAttribute::DoubleValue()
 {
     return m_pAttribute->DoubleValue();
 }

 int CUDXmlAttribute::IntValue()
 {
     return m_pAttribute->IntValue();
 }

2014-11-1118:17:15

读取邮件FolderMap.xml自定义TinyXmlDll动态库

 #ifdef XMLDLL_EXPORTS
 #define XMLDLL_API __declspec(dllexport)
 #else
 #define XMLDLL_API __declspec(dllimport)
 #endif

 #include "xml\tinyxml.h"
 #include <windows.h>
 #include <stdio.h>
 #include <tchar.h>
 #include <string>

 using namespace std;

 namespace  ParserXml{

 class CPaserXml
 {
 public:

     /*获取节点值
     *param domain_name 邮箱服务器域名
     *param folder_name 文件夹名字
     * 根据需求 return 文件夹名称(编码为UTF-8)
     */
     static XMLDLL_API std::string     GetValue(const char* domain_name,const char* folder_name,const char* filname="FolderMap.xml");

 private:
     //              判断该文件是否存在
     static XMLDLL_API BOOL            IsExist(const char* path);

     //              返回xml路径
     static XMLDLL_API string          GetAppPath(const char* filename);

     //              宽字符转到Ansi
     static XMLDLL_API std::string     WChar2Ansi(LPCWSTR pwszSrc);

     //              GB2312转到UTF-8
     static XMLDLL_API std::string     GB2312ToUTF8(const char* gb2312);

     //              UTF-8转到GB2312
     static XMLDLL_API std::string     UTF8ToGB2312(const char* utf8);
 };

 }//namespace ParserXml

 #include "ParserXml.h"
 #include <io.h>
 #include <atlstr.h>

 namespace ParserXml{

 std::string CPaserXml::GetValue(const char* domain_name,const char* folder_name,const char* filname/*="FolderMap.xml"*/)
 {
     std::string NameValue;

     string xmlname = GetAppPath(filname);

     if (IsExist(xmlname.c_str()))
     {
         TiXmlDocument Document(xmlname.c_str());

         if(Document.LoadFile())
         {
             TiXmlElement* root = Document.RootElement();
             if (root)
             {
                 TiXmlNode* item = root->FirstChild(domain_name);

                 if (item)
                 {
                     TiXmlNode* child = item->FirstChild(GB2312ToUTF8(folder_name).c_str());

                     TiXmlElement* IDElement = child->ToElement()->FirstChildElement();

                     TiXmlElement* NameElement = IDElement->NextSiblingElement();

                     const char* name = NameElement->GetText();  

                     NameValue = name;
                 }
             }
         }
     }

     return NameValue;
 }

 BOOL CPaserXml::IsExist(const char* path)
 {
     if(- != _access(path, ))
         return TRUE;
     else
         return FALSE;
 }

 string CPaserXml::GetAppPath(const char* filename)
 {
     //获取应用程序根目录

     TCHAR modulePath[MAX_PATH];
     GetModuleFileName(NULL, modulePath, MAX_PATH);
     CString strModulePath(modulePath);
     strModulePath = strModulePath.Left(strModulePath.ReverseFind(_T('\\')));

     string strPath= WChar2Ansi(strModulePath.GetBuffer());

     string seperator = "\\";

     string fullPath = strPath +seperator+filename;

     return fullPath;
 }

 std::string CPaserXml::WChar2Ansi(LPCWSTR pwszSrc)
 {
     int nLen = WideCharToMultiByte(CP_ACP, , pwszSrc, -, NULL, , NULL, NULL);
     if (nLen<= ) return std::string("");
     char* pszDst = new char[nLen];
     if (NULL == pszDst) return std::string("");
     WideCharToMultiByte(CP_ACP, , pwszSrc, -, pszDst, nLen, NULL, NULL);
     pszDst[nLen -] = ;
     std::string strTemp(pszDst);
     delete [] pszDst;
     return strTemp;
 }

 std::string CPaserXml::GB2312ToUTF8(const char* gb2312)
 {
     int len = MultiByteToWideChar(CP_ACP, , gb2312, -, NULL, );

     wchar_t* wstr = new wchar_t[len+];

     memset(wstr, , len+);

     MultiByteToWideChar(CP_ACP, , gb2312, -, wstr, len);

     len = WideCharToMultiByte(CP_UTF8, , wstr, -, NULL, , NULL, NULL);

     char* str = new char[len+];

     memset(str, , len+);

     WideCharToMultiByte(CP_UTF8, , wstr, -, str, len, NULL, NULL);

     if(wstr) delete[] wstr;

     string temp = str;
     return temp;
 }

 std::string CPaserXml::UTF8ToGB2312(const char* utf8)
 {
     int len = MultiByteToWideChar(CP_UTF8, , utf8, -, NULL, );

     wchar_t* wstr = new wchar_t[len+];

     memset(wstr, , len+);

     MultiByteToWideChar(CP_UTF8, , utf8, -, wstr, len);

     len = WideCharToMultiByte(CP_ACP, , wstr, -, NULL, , NULL, NULL);

     char* str = new char[len+];

     memset(str, , len+);

     WideCharToMultiByte(CP_ACP, , wstr, -, str, len, NULL, NULL);
     if(wstr) delete[] wstr;

     string temp = str;
     return temp;
 }

 }//namespace ParserXml