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(-1 != _access(path, 0))
        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 (0 != 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(-1 != _access(path, 0))
        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, 0, pwszSrc, -1, NULL, 0, NULL, NULL);
    if (nLen<= 0) return std::string("");
    char* pszDst = new char[nLen];
    if (NULL == pszDst) return std::string("");
    WideCharToMultiByte(CP_ACP, 0, pwszSrc, -1, pszDst, nLen, NULL, NULL);
    pszDst[nLen -1] = 0;
    std::string strTemp(pszDst);
    delete [] pszDst;
    return strTemp;
}

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

    wchar_t* wstr = new wchar_t[len+1];

    memset(wstr, 0, len+1);

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

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

    char* str = new char[len+1];

    memset(str, 0, len+1);

    WideCharToMultiByte(CP_UTF8, 0, wstr, -1, 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, 0, utf8, -1, NULL, 0);

    wchar_t* wstr = new wchar_t[len+1];

    memset(wstr, 0, len+1);

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

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

    char* str = new char[len+1];

    memset(str, 0, len+1);

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

    string temp = str;
    return temp;
}

}//namespace ParserXml