vc中通过MSXML操作XML文件

最新推荐文章于 2023-01-12 08:26:47 发布
最新推荐文章于 2023-01-12 08:26:47 发布
阅读量2k 收藏
点赞数
分类专栏： VC++程序设计 文章标签： xml null attributes interface path class

http://www.codeproject.com/cpp/C___XML_wrapper.asp

对XML文件操作的时候,先安装XML解析器,并要到进行初始话,然后就可以用下面的封装好的类对XML文件进行读和写的操作了.

初始话很简单(和ADO的初始话工作类似),下边以基于对话框的工程(TEST)为例,进行初始话

只要在TEST.CPP的InitInstance()方法中加入

AfxOleInit();

就可以了.

// XmlNodeWrapper.h: interface for the CXmlNodeWrapper class.
//
//

#if !defined(AFX_XMLNODEWRAPPER_H__43622334_FDEB_4175_9E6D_19BBAA3992A5__INCLUDED_)
#define AFX_XMLNODEWRAPPER_H__43622334_FDEB_4175_9E6D_19BBAA3992A5__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#import "MSXML3.dll" named_guids
using namespace MSXML2;

class CXmlNodeWrapper 
{
public:
 CString NodeType();
 CString GetAttribVal(int index);
 CString GetAttribName(int index);
 int NumAttributes();
 void ReplaceNode(MSXML2::IXMLDOMNode* pOldNode,MSXML2::IXMLDOMNode* pNewNode);
 CString GetText();
 void SetText(LPCTSTR text);
 MSXML2::IXMLDOMNode* InsertAfter(MSXML2::IXMLDOMNode *refNode, MSXML2::IXMLDOMNode *pNode);
 CString Name();
 MSXML2::IXMLDOMNodeList* FindNodes(LPCTSTR searchStr);
 MSXML2::IXMLDOMNode* Parent();
 void RemoveNodes(LPCTSTR searchStr);
 MSXML2::IXMLDOMNode* InsertAfter(MSXML2::IXMLDOMNode* refNode, LPCTSTR nodeName);
 MSXML2::IXMLDOMNode* InsertBefore(MSXML2::IXMLDOMNode* refNode, LPCTSTR nodeName);
 MSXML2::IXMLDOMNode* Interface();
 MSXML2::IXMLDOMDocument* ParentDocument();
 CString GetXML();
 MSXML2::IXMLDOMNode* RemoveNode(MSXML2::IXMLDOMNodePtr pNode);
 MSXML2::IXMLDOMNode* InsertNode(int index,LPCTSTR nodeName);
 MSXML2::IXMLDOMNode* InsertNode(int index,MSXML2::IXMLDOMNodePtr pNode);
 long NumNodes();
 MSXML2::IXMLDOMNode* Detach();
 MSXML2::IXMLDOMNode* GetNode(LPCTSTR nodeName);
 MSXML2::IXMLDOMNode* GetNode(int nodeIndex);
 MSXML2::IXMLDOMNode* FindNode(LPCTSTR searchString);
 MSXML2::IXMLDOMNode* GetPrevSibling();
 MSXML2::IXMLDOMNode* GetNextSibling();
 void SetValue(LPCTSTR valueName,LPCTSTR value);
 void SetValue(LPCTSTR valueName,int value);
 void SetValue(LPCTSTR valueName,short value);
 void SetValue(LPCTSTR valueName,double value);
 void SetValue(LPCTSTR valueName,float value);
 void SetValue(LPCTSTR valueName,bool value);
 BOOL IsValid();
 CString GetValue(LPCTSTR valueName);

 CXmlNodeWrapper();
 CXmlNodeWrapper(MSXML2::IXMLDOMNodePtr pNode,BOOL bAutoRelease = TRUE);
 void operator=(MSXML2::IXMLDOMNodePtr pNode);
 virtual ~CXmlNodeWrapper();
private:
 BOOL m_bAutoRelease;
 MSXML2::IXMLDOMNodePtr m_xmlnode;
};

class CXmlDocumentWrapper
{
public:
 CString GetUrl();
 CString GetXML();
 BOOL IsValid();
 BOOL Load(LPCTSTR path);
 BOOL LoadXML(LPCTSTR xml);
 BOOL Save(LPCTSTR path = "");
 MSXML2::IXMLDOMDocument* Detach();
 MSXML2::IXMLDOMDocument* Clone();
 CXmlDocumentWrapper();
 CXmlDocumentWrapper(MSXML2::IXMLDOMDocumentPtr pDoc);
 MSXML2::IXMLDOMNode* AsNode();
 virtual ~CXmlDocumentWrapper();
private:
 MSXML2::IXMLDOMDocumentPtr m_xmldoc;
};

class CXmlNodeListWrapper
{
public:
 MSXML2::IXMLDOMDocument* AsDocument();
 MSXML2::IXMLDOMNode* Node(int index);
 void Start();
 MSXML2::IXMLDOMNode* Next();
 BOOL IsValid();
 int Count();
 CXmlNodeListWrapper();
 CXmlNodeListWrapper(MSXML2::IXMLDOMNodeListPtr pList);
 void operator=(MSXML2::IXMLDOMNodeListPtr pList);
 virtual ~CXmlNodeListWrapper();

private:
 MSXML2::IXMLDOMNodeListPtr m_xmlnodelist;
};

#endif // !defined(AFX_XMLNODEWRAPPER_H__43622334_FDEB_4175_9E6D_19BBAA3992A5__INCLUDED_)

// XmlNodeWrapper.cpp: implementation of the CXmlNodeWrapper class.
//
//

#include "stdafx.h"
#include "XmlNodeWrapper.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//
// Construction/Destruction
//

CXmlNodeWrapper::CXmlNodeWrapper()
{
}

CXmlNodeWrapper::CXmlNodeWrapper(MSXML2::IXMLDOMNodePtr pNode,BOOL bAutoRelease)
{
 m_xmlnode = pNode;
 m_bAutoRelease = bAutoRelease;
}
void CXmlNodeWrapper::operator=(MSXML2::IXMLDOMNodePtr pNode)
{
 if (IsValid())
  m_xmlnode.Release();// = 号的重载,优化内存,释放不用的资源
 m_xmlnode = pNode;
}

CXmlNodeWrapper::~CXmlNodeWrapper()
{
 if (!m_bAutoRelease)
  m_xmlnode.Detach();
}


CString CXmlNodeWrapper::GetValue(LPCTSTR valueName)
{
 if (!IsValid())
  return "";

 MSXML2::IXMLDOMNodePtr attribute = m_xmlnode->Getattributes()->getNamedItem(valueName);
 if (attribute)
 {
  return (LPCSTR)attribute->Gettext();
 }
 return "";
}

BOOL CXmlNodeWrapper::IsValid()
{
 if (m_xmlnode == NULL)
  return FALSE;
 if (m_xmlnode.GetInterfacePtr() == NULL)
  return FALSE;
 return TRUE;
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::GetPrevSibling()
{
 if (!IsValid())
  return NULL;
 return m_xmlnode->GetpreviousSibling().Detach();
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::GetNextSibling()
{
 if (!IsValid())
  return NULL;
 return m_xmlnode->GetnextSibling().Detach();
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::GetNode(LPCTSTR nodeName)
{
 if (!IsValid())
  return NULL;
 try{
  return m_xmlnode->selectSingleNode(nodeName).Detach();
 }
 catch (_com_error e)
 {
  CString err = e.ErrorMessage();
 }
 return NULL;
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::GetNode(int nodeIndex)
{
 if (!IsValid())
  return NULL;
 return m_xmlnode->GetchildNodes()->Getitem(nodeIndex).Detach();
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::FindNode(LPCTSTR searchString)
{
 if (!IsValid())
  return NULL;
 try{
  return m_xmlnode->selectSingleNode(searchString).Detach();
 }
 catch (_com_error e)
 {
  CString err = e.ErrorMessage();
 }
 return NULL;
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::Detach()
{
 if (IsValid())
 {
  return m_xmlnode.Detach();
 }
 else
  return NULL;
}

long CXmlNodeWrapper::NumNodes()
{
 if (IsValid())
 {
  return m_xmlnode->GetchildNodes()->Getlength();
 }
 else
  return 0;
}

void CXmlNodeWrapper::SetValue(LPCTSTR valueName,LPCTSTR value)
{
 MSXML2::IXMLDOMDocumentPtr xmlDocument = m_xmlnode->GetownerDocument();
 if (xmlDocument)
 {
  MSXML2::IXMLDOMNamedNodeMapPtr attributes = m_xmlnode->Getattributes();
  if (attributes)
  {
   MSXML2::IXMLDOMAttributePtr attribute = xmlDocument->createAttribute(valueName);
   if (attribute)
   {
    attribute->Puttext(value);
    attributes->setNamedItem(attribute);
   }
  }
 }
}

void CXmlNodeWrapper::SetValue(LPCTSTR valueName,int value)
{
 CString str;
 str.Format("%ld",value);
 SetValue(valueName,str);
}

void CXmlNodeWrapper::SetValue(LPCTSTR valueName,short value)
{
 CString str;
 str.Format("%hd",value);
 SetValue(valueName,str);
}

void CXmlNodeWrapper::SetValue(LPCTSTR valueName,double value)
{
 CString str;
 str.Format("%f",value);
 SetValue(valueName,str);
}

void CXmlNodeWrapper::SetValue(LPCTSTR valueName,float value)
{
 CString str;
 str.Format("%f",value);
 SetValue(valueName,str);
}

void CXmlNodeWrapper::SetValue(LPCTSTR valueName,bool value)
{
 CString str;
 if (value)
  str = "True";
 else
  str = "False";
 SetValue(valueName,str);
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::InsertNode(int index,LPCTSTR nodeName)
{
 MSXML2::IXMLDOMDocumentPtr xmlDocument = m_xmlnode->GetownerDocument();
 if (xmlDocument)
 {
  MSXML2::IXMLDOMNodePtr newNode = xmlDocument->createNode(_variant_t((short)MSXML2::NODE_ELEMENT),nodeName,"");
  MSXML2::IXMLDOMNode* refNode = GetNode(index);
  if (refNode)
   newNode = m_xmlnode->insertBefore(newNode.Detach(),refNode);
  else
   newNode = m_xmlnode->appendChild(newNode.Detach());
  return newNode.Detach();
 }
 return NULL;
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::InsertNode(int index,MSXML2::IXMLDOMNodePtr pNode)
{
 MSXML2::IXMLDOMNodePtr newNode = pNode->cloneNode(VARIANT_TRUE);
 if (newNode)
 {
  MSXML2::IXMLDOMNode* refNode = GetNode(index);
  if (refNode)
   newNode = m_xmlnode->insertBefore(newNode.Detach(),refNode);
  else
   newNode = m_xmlnode->appendChild(newNode.Detach());
  return newNode.Detach();
 }
 else
  return NULL;
}

CString CXmlNodeWrapper::GetXML()
{
 if (IsValid())
  return (LPCSTR)m_xmlnode->Getxml();
 else
  return "";
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::RemoveNode(MSXML2::IXMLDOMNodePtr pNode)
{
 if (!IsValid())
  return NULL;
 return m_xmlnode->removeChild(pNode).Detach();
}

/* ********************************************************************************************************* */
CXmlDocumentWrapper::CXmlDocumentWrapper()
{
 m_xmldoc.CreateInstance(MSXML2::CLSID_DOMDocument);
}

CXmlDocumentWrapper::CXmlDocumentWrapper(MSXML2::IXMLDOMDocumentPtr pDoc)
{
 m_xmldoc = pDoc;
}

CXmlDocumentWrapper::~CXmlDocumentWrapper()
{
}

BOOL CXmlDocumentWrapper::IsValid()
{
 if (m_xmldoc == NULL)
  return FALSE;
 if (m_xmldoc.GetInterfacePtr() == NULL)
  return FALSE;
 return TRUE;
}

MSXML2::IXMLDOMDocument* CXmlDocumentWrapper::Detach()
{
 if (!IsValid())
  return NULL;
 return m_xmldoc.Detach();
}

MSXML2::IXMLDOMDocument* CXmlDocumentWrapper::Clone()
{
 if (!IsValid())
  return NULL;
 MSXML2::IXMLDOMDocumentPtr xmldoc;
 xmldoc.CreateInstance(MSXML2::CLSID_DOMDocument);
 _variant_t v(xmldoc.GetInterfacePtr());
 m_xmldoc->save(v);
 return xmldoc.Detach();
}

BOOL CXmlDocumentWrapper::Load(LPCTSTR path)
{
 if (!IsValid())
  return FALSE;

 _variant_t v(path);
 m_xmldoc->put_async(VARIANT_FALSE);
 VARIANT_BOOL success = m_xmldoc->load(v);
 if (success == VARIANT_TRUE)
  return TRUE;
 else
  return FALSE;
}

BOOL CXmlDocumentWrapper::LoadXML(LPCTSTR xml)
{
 if (!IsValid())
  return FALSE;
 VARIANT_BOOL success = m_xmldoc->loadXML(xml);
 if (success == VARIANT_TRUE)
  return TRUE;
 else
  return FALSE;
}

BOOL CXmlDocumentWrapper::Save(LPCTSTR path)
{
 try
 {
  if (!IsValid())
   return FALSE;
  CString szPath(path);
  if (szPath == "")
  {
   _bstr_t curPath = m_xmldoc->Geturl();
   szPath = (LPSTR)curPath;
  }
  _variant_t v(szPath);
  if (FAILED(m_xmldoc->save(v)))
   return FALSE;
  else
   return TRUE;
 }
 catch(...)
 {
  return FALSE;
 }
}

MSXML2::IXMLDOMNode* CXmlDocumentWrapper::AsNode()
{
 if (!IsValid())
  return NULL;
 return m_xmldoc->GetdocumentElement().Detach();
}

CString CXmlDocumentWrapper::GetXML()
{
 if (IsValid())
  return (LPCSTR)m_xmldoc->Getxml();
 else
  return "";
}

CString CXmlDocumentWrapper::GetUrl()
{
 return (LPSTR)m_xmldoc->Geturl();
}

MSXML2::IXMLDOMDocument* CXmlNodeWrapper::ParentDocument()
{
 return m_xmlnode->GetownerDocument().Detach();
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::Interface()
{
 if (IsValid())
  return m_xmlnode;
 return NULL;
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::InsertBefore(MSXML2::IXMLDOMNode *refNode, LPCTSTR nodeName)
{
 MSXML2::IXMLDOMDocumentPtr xmlDocument = m_xmlnode->GetownerDocument();
 if (xmlDocument)
 {
  MSXML2::IXMLDOMNodePtr newNode = xmlDocument->createNode(_variant_t((short)MSXML2::NODE_ELEMENT),nodeName,"");
  newNode = m_xmlnode->insertBefore(newNode.Detach(),(IUnknown*)refNode);
  return newNode.Detach();
 }
 return NULL;
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::InsertAfter(MSXML2::IXMLDOMNode *refNode, LPCTSTR nodeName)
{
 MSXML2::IXMLDOMDocumentPtr xmlDocument = m_xmlnode->GetownerDocument();
 if (xmlDocument)
 {
  MSXML2::IXMLDOMNodePtr newNode = xmlDocument->createNode(_variant_t((short)MSXML2::NODE_ELEMENT),nodeName,"");
  MSXML2::IXMLDOMNodePtr nextNode = refNode->GetnextSibling();
  if (nextNode.GetInterfacePtr() != NULL)
   newNode = m_xmlnode->insertBefore(newNode.Detach(),(IUnknown*)nextNode);
  else
   newNode = m_xmlnode->appendChild(newNode.Detach());
  return newNode.Detach();
 }
 return NULL;
}

void CXmlNodeWrapper::RemoveNodes(LPCTSTR searchStr)
{
 if (!IsValid())
  return;
 MSXML2::IXMLDOMNodeListPtr nodeList = m_xmlnode->selectNodes(searchStr);
 for (int i = 0; i < nodeList->Getlength(); i++)
 {
  try
  {
   MSXML2::IXMLDOMNode* pNode = nodeList->Getitem(i).Detach();
   pNode->GetparentNode()->removeChild(pNode);
  }
  catch (_com_error er)
  {
   AfxMessageBox(er.ErrorMessage());
  }
 }
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::Parent()
{
 if (IsValid())
  return m_xmlnode->GetparentNode().Detach();
 return NULL;
}

CXmlNodeListWrapper::CXmlNodeListWrapper()
{
}
CXmlNodeListWrapper::CXmlNodeListWrapper(MSXML2::IXMLDOMNodeListPtr pList)
{
 m_xmlnodelist = pList;
}

void CXmlNodeListWrapper::operator=(MSXML2::IXMLDOMNodeListPtr pList)
{
 if (IsValid())
  m_xmlnodelist.Release();
 m_xmlnodelist = pList;
}

CXmlNodeListWrapper::~CXmlNodeListWrapper()
{

}

int CXmlNodeListWrapper::Count()
{
 if (IsValid())
  return m_xmlnodelist->Getlength();
 else
  return 0;
 
}

BOOL CXmlNodeListWrapper::IsValid()
{
 if (m_xmlnodelist == NULL)
  return FALSE;
 if (m_xmlnodelist.GetInterfacePtr() == NULL)
  return FALSE;
 return TRUE;
}

MSXML2::IXMLDOMNode* CXmlNodeListWrapper::Next()
{
 if (IsValid())
  return m_xmlnodelist->nextNode().Detach();
 else
  return NULL;
}

void CXmlNodeListWrapper::Start()
{
 if (IsValid())
  m_xmlnodelist->reset();
}

MSXML2::IXMLDOMNode* CXmlNodeListWrapper::Node(int index)
{
 if (IsValid())
  return m_xmlnodelist->Getitem(index).Detach();
 else
  return NULL;
}

MSXML2::IXMLDOMDocument* CXmlNodeListWrapper::AsDocument()
{
 if (IsValid())
 {
  CXmlDocumentWrapper doc;
  doc.LoadXML("<NodeList></NodeList>");
  CXmlNodeWrapper root(doc.AsNode());
  
  for (int i = 0; i < m_xmlnodelist->Getlength(); i++)
  {
   root.InsertNode(root.NumNodes(),m_xmlnodelist->Getitem(i)->cloneNode(VARIANT_TRUE));
  }
  return doc.Detach();
 }
 else
  return NULL;
}

MSXML2::IXMLDOMNodeList* CXmlNodeWrapper::FindNodes(LPCTSTR searchStr)
{
 if(IsValid())
 {
  try{
   return m_xmlnode->selectNodes(searchStr).Detach();
  }
  catch (_com_error e)
  {
   CString err = e.ErrorMessage();
   return NULL;
  }
 }
 else
  return NULL;
}

CString CXmlNodeWrapper::Name()
{
 if (IsValid())
  return (LPCSTR)m_xmlnode->GetbaseName();
 return "";
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::InsertAfter(MSXML2::IXMLDOMNode *refNode, MSXML2::IXMLDOMNode *pNode)
{
 MSXML2::IXMLDOMNodePtr nextNode = refNode->GetnextSibling();
 MSXML2::IXMLDOMNodePtr newNode;
 if (nextNode.GetInterfacePtr() != NULL)
  newNode = m_xmlnode->insertBefore(pNode,(IUnknown*)nextNode);
 else
  newNode = m_xmlnode->appendChild(pNode);
 return newNode.Detach();
}

void CXmlNodeWrapper::SetText(LPCTSTR text)
{
 if (IsValid())
  m_xmlnode->Puttext(text);
}

CString CXmlNodeWrapper::GetText()
{
 if (IsValid())
  return (LPCSTR)m_xmlnode->Gettext();
 else
  return "";
}

void CXmlNodeWrapper::ReplaceNode(MSXML2::IXMLDOMNode *pOldNode, MSXML2::IXMLDOMNode *pNewNode)
{
 if (IsValid())
 {
  m_xmlnode->replaceChild(pNewNode,pOldNode);
 }
}

int CXmlNodeWrapper::NumAttributes()
{
 if (IsValid())
 {
  MSXML2::IXMLDOMNamedNodeMapPtr attribs = m_xmlnode->Getattributes();
  if (attribs)
   return attribs->Getlength();
 }

 return 0;
}

CString CXmlNodeWrapper::GetAttribName(int index)
{
 if (IsValid())
 {
  MSXML2::IXMLDOMNamedNodeMapPtr attribs = m_xmlnode->Getattributes();
  if (attribs)
  {
   MSXML2::IXMLDOMAttributePtr attrib = attribs->Getitem(index);
   if (attrib)
    return (LPCSTR)attrib->Getname();
  }
 }

 return "";
}

CString CXmlNodeWrapper::GetAttribVal(int index)
{
 if (IsValid())
 {
  MSXML2::IXMLDOMNamedNodeMapPtr attribs = m_xmlnode->Getattributes();
  if (attribs)
  {
   MSXML2::IXMLDOMAttributePtr attrib = attribs->Getitem(index);
   if (attrib)
    return (LPCSTR)attrib->Gettext();
  }
 }

 
 return "";
}

CString CXmlNodeWrapper::NodeType()
{
 if (IsValid())
  return (LPCSTR)m_xmlnode->GetnodeTypeString();
 return "";
}

Augusdi
关注
专栏目录
VC++创建与读取XML文件
10-23
VC创建与读取XML文件demo Win7+VS2010实现，简单易懂，读取内容在程序启动后的“输出”面板显示
使用MSXML读取XML文档
04-07
此外，MSXML还提供了IXMLDOMAttribute接口来处理XML文档中的属性，以及IXMLDOMNode接口的`appendChild`、`removeChild`等方法进行修改操作。STL（Standard Template Library）可以在处理大量数据时提供帮助，例如，...
vc中通过MSXML操作XML文件(转贴)
龙宇网的专栏
06-10 6394
http://www.codeproject.com/cpp/C___XML_wrapper.asp对XML文件操作的时候,先安装XML解析器,并要到进行初始话,然后就可以用下面的封装好的类对XML文件进行读和写的操作了.初始话很简单(和ADO的初始话工作类似),下边以基于对话框的工程(TEST)为例,进行初始话只要在TEST.CPP的InitInstance()方法中加入AfxO
在vc中使用MSXML解析xml文件
行风
12-19 3111
(1)找了一些资料。http://www.xml.org.cn/dispbbs.asp?boardID=11&ID=23546(2)自己写的一个demo。// WebClient.cpp : Defines the entry point for the console application.//#include   "stdafx.h"   #include   afx.h> 
VC使用MSXML解析XML文档,例子代码
阿彪的Blog
01-07 3183
现在XML文档应用的方面特别的多.我把以前写过的一个例子帖出来,以备以后使用.第一部分：DOM解析：      概述：DOM解析将会把一个完整的XML文档读进来，生成一个结构树。这样会要把XML文档全部都加载到内在中。所以解析起来的速度会要慢一些。    1、如何加载xml文件：         //创建DOM,加载XML文档         MSXML::IXMLDOMDocumentPtr p
VC++中利用MSXML解析XML文档
小坏的专栏
11-02 1294
文章标题：VC++中利用MSXML解析XML文档原 作 者：侯 小 云原 出 处：不详发 布 者：loose_went发布类型：转载发布日期：2004-04-23今日浏览：11总 浏 览：2140　　摘　要：XML文档是近年来比较流行的结构化文档形式，其主要用途不只适用于开发网页，而且在其他场合也有很广泛的应用。本文主要介绍用VC++开发应用程序时对XML文档的解析
vc_cxml.rar_ vc_cxml_msxml_vc xml _xml文件_文件读取
09-14
本压缩包“vc_cxml.rar”提供了一个在Visual C++（简称VC）环境中使用MSXML库进行XML文件读取的示例项目。 MSXML是Microsoft提供的一个接口，它允许开发者在Windows平台上处理XML文档。这个库包含了多个版本，如...
VC++中利用MSXML解析XML文档.rar_Vc_XML解析_vc xml解析_visual studio 2008_xml
09-14
通过这种方式，你可以方便地读取、修改和创建XML文档，实现数据的存储和交换。记住，XML解析涉及到很多细节，如错误处理、内存管理以及XPath的使用，都需要根据具体需求进行深入学习和实践。在实际开发中，可以参考...
xml.rar_XML VC_msxml_vc xml _xml
09-22
除了读取和操作XML文档，MSXML还支持XPath查询，这使得从大型XML文档中提取特定数据变得容易。例如，你可以使用`selectNodes`方法配合XPath表达式来找到特定的节点集合。 此外，MSXML也支持XML Schema（XSD）验证，...
vc_xml.zip_msxml_vc XML_vc x_vc xml _vc_xml
09-19
在VC++（Visual C++）环境中，处理XML文件通常会涉及到MSXML库，这是一个由微软提供的API，允许开发者在Windows平台上解析和操作XML文档。 MSXML，全称Microsoft XML Core Services，提供了多种版本，如MSXML3、...
Msxml2.XMLHTTP Microsoft.XMLHTTP new XMLHttpRequest
weixin_30871701的博客
09-06 480
客户端调用XMLHTTP的过程很简单，只有5个步骤： 1、创建XMLHTTP对象 2、打开与服务端的连接，同时定义指令发送方式，服务网页(URL)和请求权限等。 客户端通过Open命令打开与服务端的服务网页的连接。与普通HTTP指令传送一样，可以用"GET"方法或"POST"方法指向服务端的服务网页。 3、发送指令。 4、等待并接收服务端返回的处理结果。 5、释放XMLHT...
VC++与MSXML
afumz68826的专栏
06-07 180
一、 XML 简介　　XML（Xtensible Markup Language，即扩展标记语言）的发展起源于1996年。当时，出版界巨头和Web业内人士经过共同讨论，提出了创建SGML（Standard Generalized Markup Language，即标准通用标识语言）子集（HML）的建议。该子集专用于Web，具有可扩展（或可扩充）性，并且能利用结构化标记语言...
VC简单调用MSXML
TXH0001的专栏
09-11 933
首先 安装msxml sdk   1、包含头文件 #include #include #pragma comment(lib, "comsuppw.lib") 2、例子代码 CComPtr pDoc; HRESULT hr
VC读写XML文档
寻找中
10-12 1607
转载http://blog.sina.com.cn/s/blog_4b5039210100issi.html 实验环境：VC++6.0 ，windows XP   需要安装MSXML 4.0 SP2      实现的功能是初始化XML文档，读取特定节点，和创建新节点删除节点等操作。XML文件如下所示：       首先我们要实现的功能是：创建一个如图所示
VC使用MSXML解析XML文档
zerokkqq的专栏
06-06 3103
VC使用MSXML解析XML文档第一部分：DOM解析：      概述：DOM解析将会把一个完整的XML文档读进来，生成一个结构树。这样会要把XML文档全部都加载到内在中。所以解析起来的速度会要慢一些。    1、如何加载xml文件：         //创建DOM,加载XML文档         MSXML::IXMLDOMDocument
VC++使用 MSXML库
最新发布
C++实习生
01-12 980
【代码】VC++使用 MSXML库。
VC++中利用MSXML解析XML、使用DOM写XML文档
thanklife的专栏
08-16 1454
CoInitialize(NULL); // 初始化COM。 CComPtr<IXMLDOMDocument> spXMLDOM; // 创建解析器实例。 HRESULT hr = spXMLDOM.CoCreateInstance (__uuidof(DOMDocument)); VARIANT_BOOL bSuccess = false; // 装载XML文档。 hr = spXMLDOM->load(CComVariant(L"xmlfile.xml"), &..
MsXml创建和解析XML示例
xuqiang918的专栏
07-02 2487
一．MsXml创建XML文档示例   [cpp] view plaincopyprint? // XmlCreationDemo.cpp    #include   #include     // 引入MSXML解析器  #import   using namespace MSXML2;    class InitializeCom  {  public:      In
VC对于XML的解析以及操作
Android & Linux
01-09 3059
XML的查找 #include #include #import #include using namespace std;void Travel(MSXML2::IXMLDOMNodePtr pDOMNode){ if (pDOMNode->GetnodeTypeString()==(_bstr_t)"element") // 获取节点类型 {  printf("%s: ", (ch
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值