xml节点的删除出错

1. //XercesParserXml.h
2. #ifndef XERCES_PARSER_XML_H__
3. #define XERCES_PARSER_XML_H__
5. #include <string>
7. class XercesParserXml {
8. public:
9.     bool has(const std::string& srcByte, const std::string& node) const;
10.     std::string get(const std::string& srcByte, const std::string& node) const;
11.     bool set(std::string& srcByte, const std::string& node, const std::string& value);
12.     bool del(std::string& srcByte, const std::string& node);
13. private:
15. };
17. #endif
19. //XercesParserXml.cpp
20. #include "XercesParserXml.h"
22. #include <xercesc/parsers/XercesDOMParser.hpp>
23. #include <xercesc/dom/DOM.hpp>
24. #include <xercesc/sax/HandlerBase.hpp>
25. #include <xercesc/util/XMLString.hpp>
26. #include <xercesc/util/PlatformUtils.hpp>
27. #include <xercesc/framework/MemBufInputSource.hpp>
29. #if defined(XERCES_NEW_IOSTREAMS)
30. #include <iostream>
31. #else
32. #include <iostream>
33. #include <iostream.h>
34. #endif
37. #include <vector>
39. XERCES_CPP_NAMESPACE_USE
41. DOMNode* getNode(DOMNode* node, const char* nodeName)
42. {
43.     //char* ptr = (char *)nodeName;
44.     char ptr[4096] = {0};
45.     sprintf(ptr, "%s", nodeName);
46.     if (NULL == ptr)
47.         return NULL;
48.     char* d = ".";
49.     char* p = NULL;
50.     p = strtok(ptr, d);
51.     std::vector<std::string> vec;
52.     while (p) 
53.     {
54.         //printf("name: %s/n", p);
55.         vec.push_back(p);
56.         p = strtok(NULL, d);
57.     }
58.     DOMNode* child;
59.     DOMNode* curNode = node;
61.     for (unsigned int i = 1; i < vec.size(); i++) 
62.     {
63.         //std::cout << vec[i] << std::endl;
64.         if (0 == curNode) {
65.             return NULL;
66.         }
67.         for (child = curNode->getFirstChild(); child != 0; child = child->getNextSibling()) { // have no child ???
68.             char *name = XMLString::transcode(child->getNodeName());
69.             if (vec[i] == name) {
70.                 //printf("vec[%d]: %s/tname: %s/n", i, vec[i].c_str(), name);
71.                 XMLString::release(&name);
72.                 curNode = child;
73.                 break;
74.             }
75.             XMLString::release(&name);
76.             if (child == curNode->getLastChild()) {
77.                 std::cout << "such node isn't exist" << std::endl;
78.                 return NULL;
79.             }
80.         }
81.     }
82.     return curNode;
83. }
86. class XStr
87. {
88. public :
89.     // -----------------------------------------------------------------------
90.     // Constructors and Destructor
91.     // -----------------------------------------------------------------------
92.     XStr(const char* const toTranscode)
93.     {
94.         // Call the private transcoding method
95.         fUnicodeForm = XMLString::transcode(toTranscode);
96.     }
98.     ~XStr()
99.     {
100.         XMLString::release(&fUnicodeForm);
101.     }
104.     // -----------------------------------------------------------------------
105.     // Getter methods
106.     // -----------------------------------------------------------------------
107.     const XMLCh* unicodeForm() const
108.     {
109.         return fUnicodeForm;
110.     }
112. private :
113.     // -----------------------------------------------------------------------
114.     // Private data members
115.     //
116.     // fUnicodeForm
117.     // This is the Unicode XMLCh format of the string.
118.     // -----------------------------------------------------------------------
119.     XMLCh* fUnicodeForm;
120. };
123. #define X(str) XStr(str).unicodeForm()
125. bool XercesParserXml::has(const std::string& srcBytes, const std::string& node) const
126. {
127.     // init
128.     try {
129.         XMLPlatformUtils::Initialize();
130.     }
131.     catch (const XMLException& toCatch) {
132.         char* message = XMLString::transcode(toCatch.getMessage());
133.         std::cout << "Error during initialization! :/n"
134.              << message << "/n";
135.         XMLString::release(&message);
136.         return false;
137.     }
138.     // 1. load the right xml bytes from signal tree
139.     XercesDOMParser* parser = new XercesDOMParser();
140.     if (NULL == parser) {
141.         return false;
142.     }
143.     parser->setValidationScheme(XercesDOMParser::Val_Always);
144.     parser->setDoNamespaces(true); // optional
145.     ErrorHandler* errHandler = (ErrorHandler*) new HandlerBase();
146.     parser->setErrorHandler(errHandler);
147.     InputSource* pInputSource = new MemBufInputSource((XMLByte *)srcBytes.c_str(), srcBytes.size(), X("GUID"));
148.     if (NULL == pInputSource) {
149.         delete parser;
150.         delete errHandler;
151.         return false;
152.     }
153.     // 2. parser the xml bytes to a DOM tree
154.     parser->parse(*pInputSource);
155.     DOMDocument* doc = parser->getDocument();
156.     if (NULL == doc) {
157.         delete parser;
158.         delete errHandler;
159.         delete pInputSource;
160.         return false;
161.     }
162.     // 3. find node of parameter in DOM tree
163.     DOMElement* rootElem = NULL;
164.     rootElem = doc->getDocumentElement();
165.     DOMNode* testNode = NULL;
166.     testNode = getNode(rootElem, node.c_str());
167.     // release source
168.     delete parser;
169.     delete errHandler;
170.     delete pInputSource;
171.     //doc->release();
172.     if (testNode == NULL) {
173.         return false;
174.     }
175.     else {
176.         return true;
177.     }
178. }
180. std::string XercesParserXml::get(const std::string& srcBytes, const std::string& node) const
181. {
182.     // init
183.     try {
184.         XMLPlatformUtils::Initialize();
185.     }
186.     catch (const XMLException& toCatch) {
187.         char* message = XMLString::transcode(toCatch.getMessage());
188.         std::cout << "Error during initialization! :/n"
189.              << message << "/n";
190.         XMLString::release(&message);
191.         return "";
192.     }
193.     // 1. load the right xml bytes from signal tree
194.     XercesDOMParser* parser = new XercesDOMParser();
195.     if (NULL == parser) {
196.         return "";
197.     }
198.     parser->setValidationScheme(XercesDOMParser::Val_Always);
199.     parser->setDoNamespaces(true); // optional
200.     ErrorHandler* errHandler = (ErrorHandler*) new HandlerBase();
201.     parser->setErrorHandler(errHandler);
202.     InputSource* pInputSource = new MemBufInputSource((XMLByte *)srcBytes.c_str(), srcBytes.size(), X("GUID"));
203.     if (NULL == pInputSource) {
204.         delete parser;
205.         delete errHandler;
206.         return "";
207.     }
208.     // 2. parser the xml bytes to a DOM tree
209.     parser->parse(*pInputSource);
210.     DOMDocument* doc = parser->getDocument();
211.     if (NULL == doc) {
212.         delete parser;
213.         delete errHandler;
214.         delete pInputSource;
215.         return "";
216.     }
217.     // 3. find node of parameter in DOM tree
218.     DOMElement* rootElem = NULL;
219.     rootElem = doc->getDocumentElement();
220.     DOMNode* testNode = NULL;
221.     testNode = getNode(rootElem, node.c_str());
222.     // get content
223.     std::string result;
224.     char* nodeValue = NULL;
225.     if (testNode) {
226.         nodeValue = XMLString::transcode(testNode->getTextContent());
227.         result = nodeValue;
228.         XMLString::release(&nodeValue);
229.     }
231.     // release source
232.     delete parser;
233.     delete errHandler;
234.     delete pInputSource;
235.     //doc->release();
237.     return result;
238. }
242. bool XercesParserXml::set(std::string& srcBytes, const std::string& node, const std::string& value)
243. {
244.     // init
245.     try {
246.         XMLPlatformUtils::Initialize();
247.     }
248.     catch (const XMLException& toCatch) {
249.         char* message = XMLString::transcode(toCatch.getMessage());
250.         std::cout << "Error during initialization! :/n"
251.              << message << "/n";
252.         XMLString::release(&message);
253.         return false;
254.     }
255.     // 1. load the right xml bytes from signal tree
256.     XercesDOMParser* parser = new XercesDOMParser();
257.     if (NULL == parser) {
258.         return false;
259.     }
260.     parser->setValidationScheme(XercesDOMParser::Val_Always);
261.     parser->setDoNamespaces(true); // optional
262.     ErrorHandler* errHandler = (ErrorHandler*) new HandlerBase();
263.     parser->setErrorHandler(errHandler);
264.     InputSource* pInputSource = new MemBufInputSource((XMLByte *)srcBytes.c_str(), srcBytes.size(), X("GUID"));
265.     if (NULL == pInputSource) {
266.         delete parser;
267.         delete errHandler;
268.         return false;
269.     }
270.     // 2. parser the xml bytes to a DOM tree
271.     parser->parse(*pInputSource);
272.     DOMDocument* doc = parser->getDocument();
273.     if (NULL == doc) {
274.         delete parser;
275.         delete errHandler;
276.         delete pInputSource;
277.         return false;
278.     }
279.     // 3. find node of parameter in DOM tree
280.     DOMElement* rootElem = NULL;
281.     rootElem = doc->getDocumentElement();
282.     DOMNode* testNode = NULL;
283.     testNode = getNode(rootElem, node.c_str());
284.     // 4. set new content
285.     if (testNode) {
286.         testNode->setTextContent(X(value.c_str()));
287.     }
289.     // 5. serialize DOM tree and save it
290.     char* result;
291.     DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
292.     if (NULL == impl) {
293.         XERCES_STD_QUALIFIER cerr << "Requested implementation is not supported" << XERCES_STD_QUALIFIER endl;
294.         XMLPlatformUtils::Terminate();
295.         delete parser;
296.         delete errHandler;
297.         delete pInputSource;
298.         return false;
299.     }
300.     DOMWriter* theSerializer = ((DOMImplementationLS*)impl)->createDOMWriter();
301.     if (NULL == theSerializer) {
302.         delete parser;
303.         delete errHandler;
304.         delete pInputSource;
305.         return false;
306.     }
307.     if (theSerializer->canSetFeature(XMLUni::fgDOMWRTDiscardDefaultContent, true))
308.         theSerializer->setFeature(XMLUni::fgDOMWRTDiscardDefaultContent, true);
309.     if (theSerializer->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true))
310.         theSerializer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true);
311.     XMLCh* unicodeStr = theSerializer->writeToString(*rootElem);
312.     result = XMLString::transcode(unicodeStr);
313.     srcBytes = result;
314.     //printf("result: %s/n", result);
315.     XMLString::release(&unicodeStr);
316.     XMLString::release(&result);
318.     // release source
319.     theSerializer->release();
320.     delete parser;
321.     delete errHandler;
322.     delete pInputSource;
324.     return true;
325. }
327. bool XercesParserXml::del(std::string& srcBytes, const std::string& node)
328. {
329.     // init
330.     try {
331.         XMLPlatformUtils::Initialize();
332.     }
333.     catch (const XMLException& toCatch) {
334.         char* message = XMLString::transcode(toCatch.getMessage());
335.         std::cout << "Error during initialization! :/n"
336.              << message << "/n";
337.         XMLString::release(&message);
338.         return false;
339.     }
340.     // 1. load the right xml bytes from signal tree
341.     XercesDOMParser* parser = new XercesDOMParser();
342.     if (NULL == parser) {
343.         return false;
344.     }
345.     parser->setValidationScheme(XercesDOMParser::Val_Always);
346.     parser->setDoNamespaces(true); // optional
347.     ErrorHandler* errHandler = (ErrorHandler*) new HandlerBase();
348.     parser->setErrorHandler(errHandler);
349.     InputSource* pInputSource = new MemBufInputSource((XMLByte *)srcBytes.c_str(), srcBytes.size(), X("GUID"));
350.     if (NULL == pInputSource) {
351.         delete parser;
352.         delete errHandler;
353.         return false;
354.     }
355.     // 2. parser the xml bytes to a DOM tree
356.     parser->parse(*pInputSource);   
357.     DOMDocument* doc = parser->getDocument();
358.     if (NULL == doc) {
359.         delete parser;
360.         delete errHandler;
361.         delete pInputSource;
362.         return false;
363.     }
364.     // 3. find node of parameter in DOM tree
365.     DOMElement* rootElem = NULL;
366.     rootElem = doc->getDocumentElement();
367.     DOMNode* testNode = NULL;
368.     testNode = getNode(rootElem, node.c_str());
369.     if (NULL == testNode) {
370.         delete parser;
371.         delete errHandler;
372.         delete pInputSource;
373.         return false;
374.     }
375.     // 4. remove identifier node from DOM tree
376.     DOMNode* parentNode = testNode->getParentNode();
377.     DOMNode* oldNode = parentNode->removeChild(testNode);
378.     oldNode->release();
380.     // 5. serialize DOM tree and save it
381.     char* result;
382.     DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
383.     if (NULL == impl) {
384.         XERCES_STD_QUALIFIER cerr << "Requested implementation is not supported" << XERCES_STD_QUALIFIER endl;
385.         XMLPlatformUtils::Terminate();
386.         delete parser;
387.         delete errHandler;
388.         delete pInputSource;
389.         return false;
390.     }
391.     DOMWriter* theSerializer = ((DOMImplementationLS*)impl)->createDOMWriter();
392.     if (NULL == theSerializer) {
393.         delete parser;
394.         delete errHandler;
395.         delete pInputSource;
396.         return false;
397.     }
398.     if (theSerializer->canSetFeature(XMLUni::fgDOMWRTDiscardDefaultContent, true))
399.         theSerializer->setFeature(XMLUni::fgDOMWRTDiscardDefaultContent, true);
400.     if (theSerializer->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true))
401.         theSerializer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true);
402.     XMLCh* unicodeStr = theSerializer->writeToString(*rootElem);
403.     result = XMLString::transcode(unicodeStr);
404.     srcBytes = result;
405.     //printf("result: %s/n", result);
406.     XMLString::release(&unicodeStr);
407.     XMLString::release(&result);
410.     // release source
411.     theSerializer->release();
412.     delete parser;
413.     delete errHandler;
414.     delete pInputSource;
416.     return true;
417. }
419. int main()
420. {
421.     char* xmlFile = "x2.xml";
423.     char buf[4096] = {0};
424.     FILE* fp = fopen(xmlFile, "rb");
425.     if (!fp) 
426.     {
427.         perror(xmlFile);
428.         exit(1);
429.     }
430.     size_t size;
431.     size = fread(buf, 1, sizeof(buf), fp);
432.     fclose(fp);
433.     std::cout << "size to be parser: " << size << std::endl;
434.     std::string srcDocBytes;
435.     srcDocBytes.assign(buf, size);
436.     std::string backup = srcDocBytes;
438.     XercesParserXml xml;
439.     bool flag = false;
440.     char testNode[1000] = {0};
441.     //其中各结点以“.”分隔，格式：root.child.grandson
442.     sprintf(testNode, "%s", "SendRoutingInfoRes.imsi"); 
443.     std::string result;
444.     for (int i = 0; i < 1; i++)
445.     {
446.         srcDocBytes = backup;
447.         printf("/nfind node test ... /n");
448.         flag = xml.has(srcDocBytes, testNode);
449.         printf("/nget node test .../n");
450.         result = xml.get(srcDocBytes, testNode);
451.         printf("get value: %s/n", result.c_str());
452.         printf("/nset node test .../n");
453.         xml.set(srcDocBytes, testNode, "gnu means gnu not unix");
454.         printf("new content: %s/n", srcDocBytes.c_str());
455.         printf("/nremove test .../n");
456.         xml.del(srcDocBytes, testNode);
457.         printf("after del operation: %s/n", srcDocBytes.c_str());
458.     }
459.     if (flag) {
460.         printf("%s has found/n", testNode);
461.     }
462.     else {
463.         printf("%s hasn't found/n", testNode);
464.     }
465. }

        从网上下了一段操作xml文件的代码，这段代码可以修改、删除、访问xml中的一个节点,感觉不是很有用，因为我想找的是能根据xml文件中元素的名称得到元素值的基本方法,根据元素名和该元素的属性名得到属性值的基本方法。

        既然已经把代码下下来了，就运行了一下，结果报错了，调试的时候发现是引用KERNEL32.DLL的时候出错了，这个错误有些奇怪，出错的代码是parser->parse(*pInputSource);这一行，经过观察发现其他的函数也有与这段完全相同的代码，但是其他函数为什么没有出错呢？为什么完全相同的一段代码放在这里不会错，放在那里就报错了？

        花了很多时间琢磨，终于找到原因了，那段代码本身是没有错误的，直接原因是main函数对子函数的调用顺序导致的，实质原因是，几个子函数对资源释放的不彻底导致的，可以这样类比，一个函数set去改写一个文本文件text，set改写了text后，没有释放资源，另一个函数del又去删除text，这时就发生资源访问冲突了。