c++用tinyxml2读xml文件，转化为字节码，解析并保存

最新推荐文章于 2024-04-27 13:01:02 发布
最新推荐文章于 2024-04-27 13:01:02 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： C/C++/QT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moonlightpeng/article/details/79724788
版权

1，配置tinyxml2文件：加tinyxml2.cpp and tinyxml2.h.

2. 主函数 main()

#include "tinyxml2.h"
#include "Scene.h"

using namespace std;
using namespace tinyxml2;


void main()
{
	XMLScene *oldScene = new XMLScene();
	oldScene->ReadXML("scene.xml");

	//encode
	char buf[DEFAULT_BUFLEN];
	int index = 0;
	oldScene->EncodeAssembly(buf, index);


	//decode
	index = 0;
	XMLScene *analyzedScene= new XMLScene();
	oldScene->DecodeAssembly(buf, index, analyzedScene);



	analyzedScene->WriteXML("newScene.xml");


}

3. Scene.h

#pragma once

#include <iostream>
#include <sstream>
#include <list>
#include "tinyxml2.h"
using namespace std;
using namespace tinyxml2;

//	相关字符串的长度
#define	LEN_NAME       32
#define	LEN_ID       32
#define	LEN_ADDRESS         256
#define  DEFAULT_BUFLEN 40960



enum NodeType{  NODE_SCENE, NODE_ASSEMBLY, NODE_PART };



class PartNode 
{
public:
	NodeType		nodeType;		// 节点类型
	//wchar_t			name[LEN_NAME];		// 节点名称
	char name[LEN_NAME];
	char ID[LEN_ID];


	char FBX_address[LEN_ADDRESS];
	double transform[3];
	double rotation[3];
	double scale[3];
//	ModelMesh		m_modelMesh;

public:
	NodeType type() { return nodeType; }


	void Set(const char * _name, const  char *  _FBX_address, double  _transform[3], double _rotation[3], double _scale[3]);
	inline int byte_size();
	virtual void ToCharArray(char buf[], int & index);


	//bool InitNode(TiXmlElement *xmlNode);

	PartNode(NodeType type) : nodeType(type) {};
	PartNode() : PartNode(NODE_PART) { };
	PartNode(char * buf, int  & index);

	virtual ~PartNode();
};



class AssemblyNode : public PartNode
{
public:
	list <PartNode*> parts;
	list <AssemblyNode*> assemblys;

public:
	AssemblyNode(char *buf, int & index);
	AssemblyNode() : PartNode(NODE_ASSEMBLY) { };
};

class XMLScene
{
public:
	//1.public variables
	double speed, delay;

	//2.assembly node
	AssemblyNode *scene;

	bool ReadXML(const char* file);
	void WriteXML(const char* xmlPath);

	void EncodeAssembly(char buf[], int& index );

	void  XMLScene::DecodeAssembly(char buf[], int  index, XMLScene * result);


	XMLScene();
	~XMLScene();
private:

};

4. Scene.cpp

#include "Scene.h"
string doubleToString(double num)
{
	char str[256];
	sprintf_s(str, "%.8lf", num);
	string result = str;
	return result;
}

string doubleArrayToStringN(double data[], int count)
{
	string temp;
	for (int i = 0; i < count - 1; i++)
	{
		temp = temp + doubleToString(data[i]) + " ";

	}
	temp += doubleToString(data[count - 1]);
	return temp;
}



void CharToDoubleN(double *buf, int n, const char * content)
{
	stringstream ss(content);
	for (int i = 0; i < n; i++)
	{
		ss >> *(buf + i);
	}
}
/*


PartNode::PartNode(char buf[], int & index)
{
	// get value of nodetype
	int  len = sizeof(NodeType);
	memcpy_s(&nodeType, len, &buf[index], len);
	index += len;

	// get value of name
	len = sizeof(char) * LEN_NAME;
	memcpy_s(&name, len, &buf[index], len);
	index += len;

	// get value of type
	len = sizeof(char) * LEN_ID;
	memcpy_s(&ID, len, &buf[index], len);
	index += len;
}



void PartNode::ToCharArray(char buf[], int &index)
{
	// nodeType
	int len = sizeof(NodeType);
	memcpy_s(&(buf[index]), len, &nodeType, len);
	index += len;

	// copy byte count of the object
	len = sizeof(name);
	memcpy_s(&(buf[index]), len, name, len);
	index += len;

	 copy id to buf 
	len = sizeof(ID);
	memcpy_s(&(buf[index]), len, ID, len);
	index += len;




	int _type;
	char _name[LEN_NAME];
	char _ID[LEN_ID];

	memcpy_s(&_type, sizeof(__int32), &buf[0], sizeof(__int32));
	memcpy_s(&_name, sizeof(char)*LEN_NAME, &buf[sizeof(__int32)], sizeof(char)*LEN_NAME);
	memcpy_s(&_ID, sizeof(char)*LEN_ID, &buf[sizeof(__int32) + sizeof(char)*LEN_NAME], sizeof(char)*LEN_ID);
}

int PartNode::base_byte_size()
{
	return sizeof(__int32) + sizeof(char)* LEN_NAME + sizeof(char)*LEN_ID;
}
*/



void PartNode::Set(const char * _name, const  char *  _FBX_address, double  _transform[3], double _rotation[3], double _scale[3])
{

	strncpy_s(name, _name, LEN_NAME);
	strncpy_s(FBX_address, _FBX_address, LEN_ADDRESS);

	for (int i = 0; i<3;i++)
	{
		transform[i] = _transform[i];
		rotation[i] = _rotation[i];
		scale[i] = _scale[i];
	}
	




}

// **************************************************************************************************************************
// class PartNode
// **************************************************************************************************************************


PartNode::PartNode(char  *buf, int & index)
{
	// get value of nodetype
	int  len = sizeof(NodeType);
	memcpy_s(&nodeType, len, &buf[index], len);
	index += len;

	// get value of name
	len = sizeof(char) * LEN_NAME;
	memcpy_s(&name, len, &buf[index], len);
	index += len;

	// get value of type
	len = sizeof(char) * LEN_ID;
	memcpy_s(&ID, len, &buf[index], len);
	index += len;




	len = sizeof(FBX_address);
	memcpy_s(FBX_address, len, &buf[index], len);				// 拷贝零件ID
	index += len;

	len = sizeof(transform);
	memcpy_s(transform, len, &buf[index], len);				// 拷贝零件ID	
	index += len;

	len = sizeof(rotation);
	memcpy_s(rotation, len, &buf[index], len);				// 拷贝零件ID
	index += len;

	len = sizeof(scale);
	memcpy_s(scale, len, &buf[index], len);				// 拷贝零件ID	
	index += len;

}

PartNode::~PartNode()
{
};



int PartNode::byte_size()
{
	int len =  sizeof(__int32) + sizeof(char)* LEN_NAME + sizeof(char)*LEN_ID;

	len += LEN_ADDRESS + 3 * sizeof(double) + 3 * sizeof(double) + 3 * sizeof(double);

	return len;
}

void PartNode::ToCharArray(char buf[], int  & index)
{	

	// nodeType
		int len = sizeof(NodeType);
		memcpy_s(&(buf[index]), len, &nodeType, len);
		index += len;

		// copy byte count of the object
		len = sizeof(name);
		memcpy_s(&(buf[index]), len, name, len);
		index += len;

		 copy id to buf 
		len = sizeof(ID);
		memcpy_s(&(buf[index]), len, ID, len);
		index += len;


/*


		int _type;
		char _name[LEN_NAME];
		char _ID[LEN_ID];

		memcpy_s(&_type, sizeof(__int32), &buf[0], sizeof(__int32));
		memcpy_s(&_name, sizeof(char)*LEN_NAME, &buf[sizeof(__int32)], sizeof(char)*LEN_NAME);
		memcpy_s(&_ID, sizeof(char)*LEN_ID, &buf[sizeof(__int32) + sizeof(char)*LEN_NAME], sizeof(char)*LEN_ID);

		
*/




	 len = LEN_ADDRESS;
	memcpy_s(&(buf[index]), len, FBX_address, len);
	index += len;

	len = sizeof(transform);
	memcpy_s(&(buf[index]), len, transform, len);
	index += len;

	len = sizeof(rotation);
	memcpy_s(&(buf[index]), len, rotation, len);
	index += len;

	len = sizeof(scale);
	memcpy_s(&(buf[index]), len, scale, len);
	index += len;
}


// **************************************************************************************************************************
// class AssemblyNode
// **************************************************************************************************************************



AssemblyNode::AssemblyNode(char *buf, int & index) : PartNode(buf, index)
{
	
}

void ReadAttributes(PartNode * part, XMLElement * EleAssembly)
{
	strncpy_s(part->name, EleAssembly->Attribute("name"), LEN_NAME);
	strncpy_s(part->ID, EleAssembly->Attribute("ID"), LEN_NAME);


	strncpy_s(part->FBX_address, EleAssembly->Attribute("FBX"), LEN_ADDRESS);

	CharToDoubleN(part->transform, 3, EleAssembly->Attribute("Transform"));

	CharToDoubleN(part->rotation, 3, EleAssembly->Attribute("Rotation"));

	CharToDoubleN(part->scale, 3, EleAssembly->Attribute("Scale"));
}

void BrowseChildren(XMLElement* xmlParent, AssemblyNode * world)
{
	XMLElement *EleAssembly = xmlParent->FirstChildElement();

	while (EleAssembly != NULL)										// 如果孩子节点不为空
	{
		if (strcmp("Part", EleAssembly->Value()) == 0)
		{
			PartNode *part = new PartNode();

			ReadAttributes(part, EleAssembly);



		/*	/ ***********START*************** /
			char buf[DEFAULT_BUFLEN];
			int index = 0;
			part.ToCharArray(buf, index);



			int _type;
			char _name[LEN_NAME];
			char _ID[LEN_ID];

			memcpy_s(&_type, sizeof(__int32), &buf[0], sizeof(__int32));
			memcpy_s(&_name, sizeof(char)*LEN_NAME, &buf[sizeof(__int32)], sizeof(char)*LEN_NAME);
			memcpy_s(&_ID, sizeof(char)*LEN_ID, &buf[sizeof(__int32) + sizeof(char)*LEN_NAME], sizeof(char)*LEN_ID);




			index = 0;
			PartNode aaa(buf, index);
			/ ************END************** /*/




			world->parts.push_back(part);


		}
		else if (strcmp("Assembly", EleAssembly->Value()) == 0)
		{		
			AssemblyNode *assembly = new AssemblyNode();

			ReadAttributes(assembly, EleAssembly);


			BrowseChildren(EleAssembly, assembly);

			world->assemblys.push_back(assembly);

		}

		EleAssembly = EleAssembly->NextSiblingElement();
	}
}

void EncodeChild(char buf[], int & index, AssemblyNode * world)
{
	cout << "index is " << index << endl;

	for (list<AssemblyNode*>::iterator it = world->assemblys.begin(); it != world->assemblys.end(); it++)
	{
		//1.attributes
		(*it)->ToCharArray(buf, index);
		//补充两个变量为装配体和零件个数，用于解析

		int	len = sizeof(int);
		int assemblySize = (*it)->assemblys.size();
		memcpy_s(&(buf[index]), len, &assemblySize, len);
		index += len;

		len = sizeof(int);
		int partSize = (*it)->parts.size();
		memcpy_s(&(buf[index]), len, &partSize, len);
		index += len;

		//2.parts
		EncodeChild(buf, index, (*it));
	}
	for (list<PartNode*>::iterator it = world->parts.begin(); it != world->parts.end(); it++)
	{
		//   count????
		(*it)->ToCharArray(buf, index);
	}
}

void XMLScene::EncodeAssembly(char buf[], int& index)
{

	int	len = sizeof(double);
	memcpy_s(&(buf[index]), len, &speed, len);
	index += len;


	len = sizeof(double);
	memcpy_s(&(buf[index]), len, &delay, len);
	index += len;


	scene->ToCharArray(buf, index);
	//补充两个变量为装配体和零件个数，用于解析

	len = sizeof(int);
	int assemblySize = scene->assemblys.size();
	memcpy_s(&(buf[index]), len, &assemblySize, len);
	index += len;

	len = sizeof(int);
	int partSize = scene->parts.size();
	memcpy_s(&(buf[index]), len, &partSize, len);
	index += len;

	EncodeChild(buf, index, scene);
}




void DecodeChild(char buf[], int & index, AssemblyNode *world)
{
	int	len = sizeof(int);
	int assemblySize;
	memcpy_s(&assemblySize, len, &(buf[index]), len);
	index += len;

	len = sizeof(int);
	int partSize;
	memcpy_s(&partSize, len, &(buf[index]), len);
	index += len;

	for (int i = 0; i <assemblySize; i++)
	{
		AssemblyNode * assembly=new AssemblyNode(buf, index);


		//EncodeChild(buf, index, world.assemblys[i]);
		DecodeChild(buf, index, assembly);
		world->assemblys.push_back(assembly);

	}
	for (int i = 0; i < partSize; i++)
	{
		//   count????
		//world.parts[i].ToCharArray(buf, index);

		PartNode * part=new PartNode(buf, index);

		world->parts.push_back(part);

		cout << "index is " << index << endl;
		cout << "decode part:" << part->name << endl;
	}
}

void  XMLScene::DecodeAssembly(char buf[], int index, XMLScene *result)
{
	int len = sizeof(speed);
	memcpy_s(&result->speed, len, &(buf[index]), len);
	index += len;

	len = sizeof(delay);
	memcpy_s(&result->delay, len, &(buf[index]), len);
	index += len;

	result->scene = new AssemblyNode(buf, index);
	//AssemblyNode world(buf, index);
	DecodeChild(buf, index, result->scene);
}

void WriteAttributes(XMLElement * ele_Part, PartNode *part)
{
	ele_Part->SetAttribute("name", part->name);
	ele_Part->SetAttribute("ID", part->ID);

	ele_Part->SetAttribute("FBX", part->FBX_address);
	ele_Part->SetAttribute("Transform", doubleArrayToStringN(part->transform, 3).c_str());
	ele_Part->SetAttribute("Rotation", doubleArrayToStringN(part->rotation, 3).c_str());
	ele_Part->SetAttribute("Scale", doubleArrayToStringN(part->scale, 3).c_str());

}

void WriteAssembly(XMLDocument &doc, XMLElement *ele_World, AssemblyNode *world)
{
	for (list<AssemblyNode*>::iterator it = world->assemblys.begin(); it != world->assemblys.end(); it++)
	{
		XMLElement* ele_Assembly = doc.NewElement("Assembly");
		ele_World->InsertEndChild(ele_Assembly);

		WriteAttributes(ele_Assembly,*(it));

		WriteAssembly(doc, ele_Assembly,*(it));
		
	}
	for (list<PartNode*>::iterator it = world->parts.begin(); it != world->parts.end(); it++)
	{
		XMLElement* ele_Part = doc.NewElement("Part");
		ele_World->InsertEndChild(ele_Part);
		WriteAttributes(ele_Part, *(it));	
	}
}

bool XMLScene::ReadXML(const char* file)
{
	XMLDocument docR;
	docR.LoadFile(file);
	if (docR.Error())
	{
		cout << "ERROR! XML file error!" << endl;
		return false;
	}

	docR.SaveFile("Formatted.xml");
	XMLElement *ele_World = docR.RootElement();
	speed = stod(ele_World->Attribute("Speed"));
	delay = stod(ele_World->Attribute("Delay"));
	XMLElement *ele_Scene = ele_World->FirstChildElement("Scene");
	if (ele_Scene != NULL)
	{
		ReadAttributes(scene, ele_Scene);
		BrowseChildren(ele_Scene, scene);
	}
	return  true;
}


void XMLScene::WriteXML(const char* xmlPath)
{
	FILE* fp;
	fopen_s(&fp, xmlPath, "w+");//创建空xml文件
	fclose(fp);

	XMLDocument doc;
	doc.LoadFile(xmlPath);//载入xml文件
	XMLDeclaration* declaration = doc.NewDeclaration();//添加xml文件头申明
	doc.InsertFirstChild(declaration);
	XMLElement *Root = doc.NewElement("World");
	doc.InsertEndChild(Root);

	Root->SetAttribute("Speed ", doubleToString(speed).c_str());
	Root->SetAttribute("Delay ", doubleToString(delay).c_str());

/*
	XMLElement* ele_Speed = doc.NewElement("Speed");
	XMLText* text_Speed = doc.NewText(doubleToString(speed).c_str());
	ele_Speed->InsertEndChild(text_Speed);
	Root->InsertEndChild(ele_Speed);

	XMLElement* ele_Delay = doc.NewElement("Speed");
	XMLText* text_Delay = doc.NewText(doubleToString(delay).c_str());
	ele_Delay->InsertEndChild(text_Delay);
	Root->InsertEndChild(ele_Delay);
*/

	//insert Head
	XMLElement* ele_World = doc.NewElement("Scene");
	Root->InsertEndChild(ele_World);

	WriteAttributes(ele_World, scene);

	WriteAssembly(doc, ele_World, scene);

	doc.SaveFile(xmlPath);
}

XMLScene::XMLScene()
{
	scene =new AssemblyNode();


}

XMLScene::~XMLScene()
{
	double scene;



}

5. scene.xml

<?xml version="1.0"?>
<!-- root name -->
<World Speed ="20.1245215500000010" Delay ="30000.0000000000000000">
    <!--
  Following is explaination of this scene XML defination.
  1.This file is defined using a TREE structure
  2.The root is world coordinate
  3.Each node and child node are defined Assembly or Part. Assembly is father node of Part.
  4.From root, can find every part in the scene
  5.Every part has attributes, include but not limited to: position, rotation, scale, model address
   
  
  How to use.
  1.The TREE includes an algorithm to traverse, insert, delete, modify each node
  2.Only analyzed and stored in Server, send ASCII code to Client for their sepcial requirement
  3.
  -->

    <Scene name="Scene 1" ID ="S01" FBX="https://leg01" Transform="10 20 10" Rotation="1 2 3" Scale="1 1 1">
        <!--Assembly name="room" ID="A01"-->
        <Assembly name="desk" ID="A01" FBX="https://leg01" Transform="10 20 10" Rotation="1 2 3" Scale="1 1 1">
            <Assembly name="desk2" ID="A02" FBX="https://leg01" Transform="10 20 10" Rotation="1 2 3" Scale="1 1 1">
                <Part name="leg3" ID="P03" FBX="https://leg01" Transform="10.0000000000000000 20.0000000000000000 10.0000000000000000" Rotation="1 2 3" Scale="1 1 1"/>
                <Part name="leg4" ID="P04" FBX="https://leg01" Transform="10 20 10" Rotation="1 2 3" Scale="1 1 1"/>
            </Assembly>
            <Part name="leg1" ID="P01" FBX="https://leg01" Transform="10 20 10" Rotation="1 2 3" Scale="1 1 1"/>
            <Part name="leg2" ID="P02" FBX="https://leg01" Transform="10 20 10" Rotation="1 2 3" Scale="1 1 1"/>
        </Assembly>
        <Assembly name="desk2" ID="A02" FBX="https://leg01" Transform="10 20 10" Rotation="1 2 3" Scale="1 1 1">
            <Part name="leg3" ID="P03" FBX="https://leg01" Transform="10 20 10" Rotation="1 2 3" Scale="1 1 1"/>
            <Part name="leg4" ID="P04" FBX="https://leg01" Transform="10 20 10" Rotation="1 2 3" Scale="1 1 1"/>
        </Assembly>
        <Part name="leg5" ID="P05" FBX="https://leg01" Transform="10 20 10" Rotation="1 2 3" Scale="1 1 1"/>
        <Part name="leg6" ID="P06" FBX="https://leg01" Transform="10 20 10" Rotation="1 2 3" Scale="1 1 1"/>
        <Part name="leg9" ID="P07" FBX="https://leg01" Transform="10 20 10" Rotation="1 2 3" Scale="1 1 1"/>
    </Scene>
</World>

天人合一peng
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tinyXML Json接口实现
11-06
tinyXML Json接口实现 封装了tinyXml和Jxon常用操作另有有测试代码 VS2008测试通过
cocos2d-x 使用TinyXML2存储数据：
445822357
06-27 78
最近换了cocos2d-x劳动节版，原来版本的CCUserDefault使用的是libxml2,劳动节版的使用了TinyXML2（貌似2.1.2就换了），有国外开发者说，他升级引擎后什么都没干，游戏在安卓上的加载时间从20秒缩短到了5秒。 因为CCUserDefault没有提供对节点属性的操作，所以我就简单写了一下针对节点内容以及节点属性的操作，简单封装，与大家分享下，基本该有的操作应该是全...
通过C++开源库TinyXML2解析和生成XML数据
最新发布
new9232的博客
04-27 1207
TinyXML2是一个轻量级的、开源的C++库，专门用于解析和生成XML文档。它是原始TinyXML库的一个升级版本，设计得更为高效和强大，同时保持了简单易用的特点。TinyXML2非常适合那些需要处理XML数据，而又希望保持代码简洁和执行效率的应用场景。
让TinyXML保存文件为UTF-8格式
CHL123456789的专栏
10-10 1507
TinyXML是个好东西，这个不用我多说了，我用它做过好几个项目，但这几个项目都只是从xml文件中获取信息，没有涉及到写文件，最近需要生成xml的配置文件，才注意到这个问题，那就是TinyXML似乎不能保存文件为UTF-8格式。 我用UltraEdit打开生成的xml文件，UltraEdit把它识别为ASCII格式的文本文件，而通过二进制查看，也确实如此，我看了下帮助文档，也没具体提及到这个问题
cocos2d-x 配置 tinyxml 库
Norton的专栏
06-23 1820
1.去tinyxml官网下载压缩包，解压后，把.h和.cpp文件复制到你的具体项目的class类下，然后添加到项目中。（可以单独起一个tinyxml文件夹存放这些文件） 2.在要用到解析库的地方，添加头文件：include "tinyxml.h"  和 include "tinystr.h" 通过上面配置可见，tinyxml是一个简单轻量级的第三方库 下面，请看代码 voi
tinyxml2存储xml数据简单高效
qq_38409301的博客
12-29 496
重点：git地址：https://github.com/leethomason/tinyxml2tinyxml2的安装非常简单，从git下载，一共只需要两个文件tinyxml2.h和tinyxml2.cpp。而且tingxml2和C++版本无关，不依赖于STL和RTTI。所有任何版本的C++都能使用。如果要存储下拉格式的数据一：创建xml文件。
XML解析工具- TinyXML2 -源代码 - C++
02-10
TinyXML-2 是一个简单、小型、高效的 C++ XML 解析器，可以被轻松集成到其他程序中。它使用文档对象模型（DOM）的方式解析XML，可解析 XML 文档，并根据该文档构建可读取、修改和保存的文档对象模型。 作为XML解析...
C++ XML文件解析库 tinyxml2
07-02
**C++ XML文件解析库 TinyXML2** XML（eXtensible Markup Language）是一种用于标记数据的语言，广泛应用于网络服务、配置文件、数据交换、对象序列化等领域。TinyXML2是一个轻量级、高效的C++库，专为解析和操作...
【C++基于tinyxml2】XML文件读、写、解析 测试【支持中文】
08-17
【C++基于tinyxml2】XML文件读、写、解析 测试【支持中文】
c++中用TINYXML解析XML文件
08-19
本文将深入探讨如何使用TinyXML库在C++中解析XML文件。 首先， TinyXML库的主要特点是其基于DOM（Document Object Model）模型的设计。DOM是一种将XML文档转化为可编程对象模型的方法，允许开发者遍历、修改和创建...
C++ 使用TinyXML解析XML文件 源码
10-18
下面我们将详细探讨如何在C++中使用TinyXML来解析XML文件： 1. **TinyXML的安装与集成**： 在项目中使用TinyXML，首先需要下载TinyXML库，将其包含的头文件（如"tinyxml.h"）和源文件（如"tinyxml.cpp"）添加到...
tinyxml 的加载和保存
CAir2的专栏
03-12 645
tinyxml 的加载和保存
Tinyxml 创建xml 并以string形式进行解析 及中文处理
u013002364的专栏
11-11 7251
关于Tinyxml的故事就不多说了，本文主要讲怎么利用它创建xml文档 以 xml string形式在内存中解析xml ，以及关于UTF-8编码格式的XML文件如何写入、显示中文字符串等细节问题。 下载Tinyxml Address：http://www.grinninglizard.com/tinyxml/ 文档详解Address：http://www.grinninglizard.com/...
在C++中Tinyxml的基本使用
糯诺诺米团
07-13 562
1：用程序打开xml文件 该xml文件的名称是“Base.xml”，用CString strFileName存储 TiXmlDocument *XMLDoc = 0; TiXmlElement *XMLRoot; //如果不进行字符串的转换，会打不开文件 CStringA pt = CT2A(strFileName); XMLDoc = new TiXmlDocument(pt);
tinyxml2的使用
冷月无心
12-15 681
使用tinyxml2序列化一个对象到一个xml中，并且可以反序列xml化到一个对象
Tinyxml之递归解析
Top coder
05-19 1052
<br />#include "stdafx.h" #include "tinystr.h" #include "tinyxml.h" void Parse(TiXmlNode* pNode, int nLevel) { while (pNode) { TiXmlElement * pElement = pNode->ToElement(); bool bIsRemove = false; if (pElement) { if (strcmp (pElem
xml文件中CDATA字段的写入-tinyxml2
ISmileLi的博客
02-08 595
tinyxml2写入CDATA字段问题
TinyXml写入字符串的办法
weixin_34204057的博客
01-08 620
1 TiXmlElement *in_elem = new TiXmlElement("tagname"); 2 TiXmlText *text = new TiXmlText( "Hello World" ); 3 in_elem-&gt;LinkEndChild(text); 4 TiXmlPrinter printer; 5 in_elem-&gt;Ac...
c/c++操作xml库-Tinyxml2入门及高级用法
Blueeyedboy521的博客
05-07 4787
一、概念 TinyXML2是一个开源、简单、小巧、高效的C++ XML解析器，它只有一个.h文件和一个.cpp文件组成，可以轻松集成到其它程序中。它解析XML文档并从中构建可以读取、修改和保存的文档对象模型(Document Object Model, DOM)。它不能解析DTD(Document Type Definitions, 文档类型定义)或XSL(eXtensible Stylesheet Language, 扩展样式表语言)。在TinyXML2中，XML数据被解析为可以浏览和操作的C++对象，然
c++中tinyxml2
07-18
1. 易于使用：tinyxml2库的API设计简单、易于理解和操作，可以方便地读取和解析XML文件中的数据。 2. 快速且内存占用低：tinyxml2库使用了基于迭代器的解析算法，解析速度快，而且内存占用较小。 3. 跨平台兼容性：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值