xml 文件树结构用c++读入并保存

最新推荐文章于 2022-12-09 22:41:14 发布
最新推荐文章于 2022-12-09 22:41:14 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： C/C++/QT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moonlightpeng/article/details/79790310
版权
h 
class Base_NameID
{
public:
	NodeType		nodeType;		// 节点类型
	int counts;
	char name[LEN_NAME];
	char ID[LEN_ID];

public:
	NodeType type() { return nodeType; }
	void Set(const char * _name);
	inline int byte_size();
	virtual void ToCharArray(char buf[], int & index);

	//在定义时必须指定Node类型
	Base_NameID(NodeType type) : nodeType(type),counts(0) {};
	Base_NameID(char * buf, int  & index);
	Base_NameID();
	~Base_NameID();
};





//定义基类：开始、结束时间
class Base_StartEnd
{
public:
	int start;
	int end;
public:
	virtual	void ToCharArray(char buf[], int & index);
	//在定义时必须指定Node类型	
	Base_StartEnd(char * buf, int  & index);
	Base_StartEnd();
	~Base_StartEnd();
};



class Vector3d:public Base_StartEnd
{
public:
	NodeType		nodeType;		// 节点类型
	double value[3];
	//声明Vector类型，0：平移，1：旋转
	Vector3d(NodeType type);

	Vector3d(NodeType _type, double data[3]);
	Vector3d(char * data, int & index);
	void ToCharArray(char buf[], int & index);
	~Vector3d();
};

//三种，包括模型、工具、手，必须先指定节点类型
class GameObject : public Base_NameID, public Base_StartEnd
{
public:
	list<Vector3d * > animations;
	GameObject(char * data, int & index);
	void ToCharArray(char buf[], int & index);
	GameObject( NodeType type);
	~GameObject();
};


class Process : public Base_NameID, public Base_StartEnd
{
public:
	list<GameObject * > gameObjects;

	//hand
	//results
	Process(char * data, int & index);
	void ToCharArray(char buf[], int & index);

	Process();
	~Process();
};



class AssemblyOrder : public Base_NameID
{
public:
	Base_NameID*  user;
	Base_NameID* scene;
	list<Process*>  processes;
	Base_NameID* result;

	AssemblyOrder(char * data, int & index);

	bool ReadXML(const char* file);
	void WriteXML(const char* xmlPath);
	void EncodeAO(char buf[], int & index);


	AssemblyOrder();
	~AssemblyOrder();
};

string doubleToString(double num);
string doubleArrayToStringN(double data[], int count);
void CharToDoubleN(double *buf, int n, const char * content);

cpp

#include "Scene.h"
// *********************************************************************************************************
// class Base_NameID
// *********************************************************************************************************

void Base_NameID::Set(const char * _name)
{
	strncpy_s(name, _name, LEN_NAME);
}

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

	// all count
	len = sizeof(__int32);
	memcpy_s(&counts, 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;
}

Base_NameID::~Base_NameID()
{

};

Base_NameID::Base_NameID()
{
	nodeType = NodeType::NODE_AO;
};

int Base_NameID::byte_size()
{
	int len = sizeof(__int32)*2 + sizeof(char)* LEN_NAME + sizeof(char)*LEN_ID;
	len += LEN_ADDRESS + 3 * sizeof(double) + 3 * sizeof(double) + 3 * sizeof(double);
	return len;
}

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

	//counts 
	len = sizeof(__int32);
	memcpy_s(&(buf[index]), len, &counts, 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;
}
// ****************************************************************************************************************
// class Base_StartEnd
// *************************************************************************************************************

Base_StartEnd::Base_StartEnd(char  *buf, int & index)
{
	int  len = sizeof(int);
	memcpy_s(&start, len, &buf[index], len);
	index += len;

	// get value of type
	len = sizeof(int);
	memcpy_s(&end, len, &buf[index], len);
	index += len;
}

Base_StartEnd::~Base_StartEnd()
{
};
Base_StartEnd::Base_StartEnd()
{
};

void Base_StartEnd::ToCharArray(char buf[], int  & index)
{
	// copy byte count of the object
	int len = sizeof(int);
	memcpy_s(&(buf[index]), len, &start, len);
	index += len;

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

// ***********************************************************************************************************
// class Vector3d
// ***********************************************************************************************************

Vector3d::Vector3d(NodeType type)
{
	nodeType = type;
}

Vector3d::~Vector3d()
{
}

Vector3d::Vector3d(NodeType _type, double data[3])
{
	nodeType = _type;
	value[0] = data[0];
	value[1] = data[1];
	value[2] = data[2];
}

Vector3d::Vector3d(char * data, int & index)
{

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

	Base_StartEnd * temp = new Base_StartEnd(data, index);
	start = temp->start;
	end = temp->end;

	len = sizeof(double);
	memcpy_s(&value[0], len, &(data[index]), len);
	index += len;

	len = sizeof(double);
	memcpy_s(&value[1], len, &(data[index]), len);
	index += len;

	len = sizeof(double);
	memcpy_s(&value[2], len, &(data[index]), len);
	index += len;
}
void Vector3d::ToCharArray(char buf[], int & index)
{
	// nodeType
	int len = sizeof(NodeType);
	memcpy_s(&(buf[index]), len, &nodeType, len);
	index += len;

	Base_StartEnd::ToCharArray(buf, index);

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

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

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

// ****************************************************************************************************************
// class GameObject
// ****************************************************************************************************************

GameObject::GameObject(NodeType type) :Base_NameID(type)
{

}

GameObject::~GameObject()
{
}

GameObject::GameObject(char * data, int & index) :Base_NameID(data, index), Base_StartEnd(data, index)
{
	int count;
	int len = sizeof(int);
	memcpy_s(&count, len, &(data[index]), len);
	index += len;
	for (int i = 0; i < count; i++)
	{
		//Vector3d * vec = new Vector3d();
		animations.push_back(new Vector3d(data, index));
	}
}

void GameObject::ToCharArray(char buf[], int & index)
{
	Base_NameID::ToCharArray(buf, index);
	Base_StartEnd::ToCharArray(buf, index);

	int count = animations.size();
	int len = sizeof(int);
	memcpy_s(&(buf[index]), len, &count, len);
	index += len;

	for (list<Vector3d*>::iterator it = animations.begin(); it != animations.end(); it++)
	{
		(*it)->ToCharArray(buf, index);
	}
}

// **************************************************************************************************************
// class Process
// ************************************************************************************************************
Process::Process() :Base_NameID(NodeType::NODE_PROCESS)
{

}

Process::~Process()
{

}

Process::Process(char * data, int & index) :Base_NameID(data, index), Base_StartEnd(data, index)
{
	int count;
	int len = sizeof(int);
	memcpy_s(&count, len, &(data[index]), len);
	index += len;

	for (int i = 0; i < count; i++)
	{
		//Vector3d * vec = new Vector3d();
		gameObjects.push_back(new GameObject(data, index));
	}
}

void Process::ToCharArray(char buf[], int & index)
{
	Base_NameID::ToCharArray(buf, index);
	Base_StartEnd::ToCharArray(buf, index);

	int count = gameObjects.size();
	int len = sizeof(int);
	memcpy_s(&(buf[index]), len, &count, len);
	index += len;

	for (list<GameObject*>::iterator it = gameObjects.begin(); it != gameObjects.end(); it++)
	{
		(*it)->ToCharArray(buf, index);
	}
}

// **********************************************************************************************
// class AssemblyOrder
// *********************************************************************************************

AssemblyOrder::AssemblyOrder() :Base_NameID(NODE_AO)
{

	user = new Base_NameID();
	user->nodeType = NODE_USER;
	scene = new Base_NameID(NODE_SCENE);

	result = new Base_NameID(NODE_RESULT);
}

AssemblyOrder::~AssemblyOrder()
{
}

AssemblyOrder::AssemblyOrder(char * data, int& index) :Base_NameID(data, index)
{
	user = new Base_NameID(data, index);
	scene = new Base_NameID(data, index);

	int count;
	int len = sizeof(int);
	memcpy_s(&count, len, &(data[index]), len);
	index += len;

	for (int i = 0; i < count; i++)
	{
		processes.push_back(new Process(data, index));
	}


}

void AssemblyOrder::EncodeAO(char buf[], int &index)
{
	Base_NameID::ToCharArray(buf, index);

	user->ToCharArray(buf, index);
	scene->ToCharArray(buf, index);

	int count = processes.size();
	int	len = sizeof(int);
	memcpy_s(&(buf[index]), len, &count, len);
	index += len;

	for (list<Process*>::iterator it = processes.begin(); it != processes.end(); it++)
	{
		(*it)->ToCharArray(buf, index);
	}

	//	result->ToCharArray(buf, index);
	int aoNodeType = 203;
	memcpy_s(&(buf[0]), len, &aoNodeType, len);
	//counts 
	memcpy_s(&(buf[sizeof(__int32)]), len, &index, len);
}

void WriteAttributes_NameID(XMLElement * ele_Part, Base_NameID *baseProp)
{
	ele_Part->SetAttribute("name", baseProp->name);
	ele_Part->SetAttribute("ID", baseProp->ID);
}

void WriteAttributes_StartEnd(XMLElement * ele_Part, Base_StartEnd *baseProp)
{
	ele_Part->SetAttribute("start", baseProp->start);
	ele_Part->SetAttribute("end", baseProp->end);
}

void ReadAttributes_NameID(Base_NameID * baseProp, XMLElement * EleAssembly)
{
	strncpy_s(baseProp->name, EleAssembly->Attribute("name"), LEN_NAME);
	strncpy_s(baseProp->ID, EleAssembly->Attribute("ID"), LEN_ID);
}

void ReadAttributes_StartEnd(Base_StartEnd * baseProp, XMLElement * EleAssembly)
{
	baseProp->start = EleAssembly->IntAttribute("start");
	baseProp->end = EleAssembly->IntAttribute("end");
}

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

	docR.SaveFile("Formatted_AO.xml");
	XMLElement *ele_AO = docR.RootElement();
	ReadAttributes_NameID(this, ele_AO);

	XMLElement *ele_User = ele_AO->FirstChildElement("User");
	ReadAttributes_NameID(user, ele_User);
	ReadAttributes_NameID(scene, ele_AO->FirstChildElement("Scene"));

	XMLElement *ele_process = ele_AO->FirstChildElement("Process");

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

			ReadAttributes_NameID(path, ele_process);
			ReadAttributes_StartEnd(path, ele_process);

			XMLElement *ele_gameobject = ele_process->FirstChildElement();
			while (ele_gameobject != NULL)										// 如果孩子节点不为空
			{
				if (strcmp("Object", ele_gameobject->Value()) == 0 || strcmp("Tools", ele_gameobject->Value()) == 0)
				{
					GameObject * object;
					if (strcmp("Object", ele_gameobject->Value()) == 0)
						object = new GameObject(NodeType::NODE_OBJECT);

					if (strcmp("Tools", ele_gameobject->Value()) == 0)

						object = new GameObject(NodeType::NODE_TOOLS);

					ReadAttributes_NameID(object, ele_gameobject);
					ReadAttributes_StartEnd(object, ele_gameobject);

					XMLElement *ele_vector = ele_gameobject->FirstChildElement();
					while (ele_vector != NULL)										// 如果孩子节点不为空
					{
						if (strcmp("Translate", ele_vector->Value()) == 0)
						{
							Vector3d * vector = new Vector3d(NodeType::NODE_TRANSLATE);
							ReadAttributes_StartEnd(vector, ele_vector);
							CharToDoubleN(vector->value, 3, ele_vector->GetText());
							object->animations.push_back(vector);
						}
						if (strcmp("Rotate", ele_vector->Value()) == 0)
						{
							Vector3d * vector = new Vector3d(NodeType::NODE_ROTATE);
							ReadAttributes_StartEnd(vector, ele_vector);
							CharToDoubleN(vector->value, 3, ele_vector->GetText());
							object->animations.push_back(vector);
						}

						ele_vector = ele_vector->NextSiblingElement();
					}
					path->gameObjects.push_back(object);

				}
				if (strcmp("Hands", ele_gameobject->Value()) == 0)
				{

					//path->gameObjects.push_back(object);
				}
				ele_gameobject = ele_gameobject->NextSiblingElement();
			}
			processes.push_back(path);
		}
		ele_process = ele_process->NextSiblingElement();
	}

	//ReadAttributes(result, ele_AO->FirstChildElement("Result"));
	return  true;
}

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

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

	WriteAttributes_NameID(Root, this);

	//insert Head
	XMLElement* ele_User = doc.NewElement("User");
	Root->InsertEndChild(ele_User);
	WriteAttributes_NameID(ele_User, user);

	XMLElement* ele_Scene = doc.NewElement("Scene");
	Root->InsertEndChild(ele_Scene);
	WriteAttributes_NameID(ele_Scene, scene);

	//1
	for (list<Process*>::iterator it_process = processes.begin(); it_process != processes.end(); it_process++)
	{
		XMLElement* ele_Process = doc.NewElement("Process");
		Root->InsertEndChild(ele_Process);
		WriteAttributes_NameID(ele_Process, *it_process);
		WriteAttributes_StartEnd(ele_Process, *it_process);

		//2
		for (list<GameObject*>::iterator it_gameobject = (*it_process)->gameObjects.begin(); it_gameobject != (*it_process)->gameObjects.end(); it_gameobject++)
		{
			XMLElement* ele_GameObject;
			if ((*it_gameobject)->nodeType == NodeType::NODE_OBJECT)
			{
				ele_GameObject = doc.NewElement("Object");
			}
			else if ((*it_gameobject)->nodeType == NodeType::NODE_TOOLS)
			{
				ele_GameObject = doc.NewElement("Tools");
			}
			ele_Process->InsertEndChild(ele_GameObject);
			WriteAttributes_NameID(ele_GameObject, *it_gameobject);
			WriteAttributes_StartEnd(ele_GameObject, *it_gameobject);

			//3
			for (list<Vector3d*>::iterator it_vector = (*it_gameobject)->animations.begin(); it_vector != (*it_gameobject)->animations.end(); it_vector++)
			{
				XMLElement* ele_Vector;
				if ((*it_vector)->nodeType == NodeType::NODE_TRANSLATE)
				{
					ele_Vector = doc.NewElement("Translate");
				}
				else if ((*it_vector)->nodeType == NodeType::NODE_ROTATE)
				{
					ele_Vector = doc.NewElement("Rotate");
				}
				ele_GameObject->InsertEndChild(ele_Vector);
				WriteAttributes_StartEnd(ele_Vector, *it_vector);
			}
		}
	}
	/*
	XMLElement* ele_Result = doc.NewElement("Result");
	Root->InsertEndChild(ele_Result);
	WriteAttributes(ele_Result, result);*/

	doc.SaveFile(xmlPath);
}


xml


<?xml version="1.0"?>
<!-- 工序名字，作为根节点，属性为AO名字和ID编号-->
<AO name="process01" ID="AO1">
    <!--内容包含：操作人员、工具工装、零部件、如何操作（人和零部件的路径）、结果  -->
    <!--操作人员，制定名字和ID-->
    <User name="zhangli" ID="U01"/>
    <!--本AO对应的场景入口，需要和场景文件一致-->
    <Scene name="desk" ID="A01"/>
    <!--依次定义动画路径，包括动画对象(人、零件)，平移和旋转矢量-->
    <!--一个工步，可以有多个-->
    <Process name="p1" ID="P1" start="0" end="1000">

	<!--操作的物体，可以有多个，但必须有-->
        <Object name="leg3" ID="P03" start="0" end="800">
            <Translate start="0" end="100">100 200 300</Translate>
            <Translate start="300" end="350">-50 0 30</Translate>
            <Rotate start="350" end="450">30 50 30</Rotate>
            <Translate start="450" end="800">30 50 60</Translate>
        </Object>

	<!--工具、工装，可以有多个，也可以没有-->

        <Tools name="tool1" ID="T01" start="500" end="1000">
            <Translate start="500" end="1000">100 200 300</Translate>
            <Translate start="500" end="1000">-50 0 30</Translate>
            <Rotate start="500" end="1000">30 50 30</Rotate>
            <Translate start="600" end="1000">30 50 60</Translate>
        </Tools>
		
	<!--手，可以有多个，也可以没有-->

        <Hands name="left" ID="Left" start="500" end="1000">
            <Translate PointID="1" start="500" end="1000">100 200 300</Translate>
            <Translate PointID="2" start="500" end="1000">-50 0 30</Translate>
            <Translate PointID="5" start="500" end="1000">30 50 60</Translate>
        </Hands>

	<!--对特定的工艺，result内的元素是明确的-->
        <Result>
            <Isfinished name="螺纹安装是否完成" value="yes/no"/>
            <Isfinished name="螺纹安装力矩" value="0.01牛米"/>
            <Isfinished name="螺纹安装缝隙" value="0.01mm"/>
        </Result>
    </Process>

	
</AO>

天人合一peng
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ XML文件的读取及写入
weixin_43896283的博客
07-04 1180
介绍三方库的下载方法，并给出基于c++的xml文件读取、保存方法
【OpenCV 4开发详解】保存和读取XML和YMAL文件
小白学视觉
01-07 949
本文首发于“小白学视觉”微信公众号，欢迎关注公众号 本文作者为小白，版权归人民邮电出版社发行所有，禁止转载，侵权必究！ 经过几个月的努力，小白终于完成了市面上第一本OpenCV 4入门书籍《OpenCV 4开发详解》。为了更让小伙伴更早的了解最新版的OpenCV 4，小白与出版社沟通，提前在公众号上连载部分内容，请持续关注小白。 除了图像数据之外，有时程序中的尺寸较小的Mat类矩阵、字符串...
【语言-C++】xml格式的读取和保存-TimyXml
少莫千华
04-15 1631
.h // 下列 ifdef 块是创建使从 DLL 导出更简单的 // 宏的标准方法。此 DLL 中的所有文件都是用命令行上定义的 XML_EXPORTS // 符号编译的。在使用此 DLL 的 // 任何其他项目上不应定义此符号。这样，源文件中包含此文件的任何其他项目都会将 // XML_API 函数视为是从 DLL 导入的，而此 DLL 则将用此宏定义的 // 符号视为是被导出的。 #pra
c++解析xml文件到结构体
huangshuo0的博客
12-09 1290
XML文件是一种常见的用于存储数据的格式。在C++中，可以使用多种方法来解析XML文件。其中一种方法是使用C++的标准库中的和头文件中的流对象。例如，下面是一个示例代码，用于解析XML文件，并将其中的数据存储在C++结构体中：
以XML文件存储配置数据的技术实现，c++
searoc
01-05 4494
一般新手通常只是使用类似的Xerces, TinyXML之类的XML解析xml，这种方式实际上很浪费时间，自己编写很多代码也容易出错。因为，他们经常要写一个XML对象Entity的类，并附着一堆对象解析的code。工作量比较大。使用XML Schema工具，XSD设计工具，然后通过工具生成EntityClass和Paser class。我不知道这种技术确切的起源时间，但是我知道这种用法
C++读入XML文件
01-21
近要做一个VRP的算法，测试集都是放在Xml文件中，而我的算法使用C++来写，所以需要用C++来读取Xml文件。 　在百度上搜“C++读取Xml文件”，可以出来很多博客，大多数是关于tinyXml的，所以这篇博文也是讲述如何用...
xmltree-rs：将XML文件读入简单的树结构
02-06
总之，`xmltree-rs`是一个强大的Rust库，它简化了XML文件的处理，提供了一种直观的方式将XML数据转化为易于操作的树结构。无论你是要解析XML配置文件，还是从XML Web服务中提取数据，这个库都是一个理想的选择。通过...
操作xml文件_保存xml文件_操作XML_
10-01
总结，操作XML文件包括创建XML文档、使用不同类型的解析器进行读取、通过DOM进行修改以及使用TransformerAPI保存。这些基本操作构成了XML处理的核心，掌握它们对于任何涉及XML的工作都至关重要。在实际开发中，还...
利用C++读取XML文件
06-13
通过以上步骤，你可以使用C++和TinyXML库轻松地读取和解析XML文件。这只是一个基础示例，实际上，TinyXML提供了更高级的功能，如修改XML文档、保存到文件以及处理更复杂的XML结构。在实际项目中，可以根据具体需求...
treeView2xml_树控件转化成Xml文件_
10-03
在IT领域，树形控件...总之，"treeView2xml"项目涉及了树形控件操作、数据遍历、XML结构构建和文件写入等多个编程技术，这些都是软件开发中常见的技能。理解和掌握这些知识点对于提升IT专业技能是非常有价值的。
解析XML文档 实现树结构实例
02-18
开发环境为VC，基于对话框，用msxml组件解析XML文档，运用递归循环的方法实现树结构，支持中文，可以运行的一个实例。
xml与C++互转
07-31
XML 与c++转化 个例子假设你在用一个XML文件来加载和保存你的应用程序配置，举例来说，有点像example4.xml。 有许多方法可以做到这点。例如，看看TinyBind项目：http://sourceforge.net/projects/tinybind 这一节展示了一种普通老式的方法来使用XML加载和保存一个基本的对象结构。
自己写的任意节点树，可用于XML解析
12-06
自己写的任意节点树，可用于XML解析
tree的增删改保存读取
09-11
tree控件的增，删，改，保存与读取。他的功能是一个简单地通讯录，对联系人进行操作，保存到文件里 和从文件中读取。
C++结构体和json/xml之间互相转换
02-09
用于在C++结构体和json/xml之间互相转换, bson在xbson中支持。 只需要头文件, 无需编译库文件。 具体可以参考example的例子
C++读写配置xml文件（二）
rjszcb的博客
07-14 2069
一、c++读写xml文件 1、定义了两个类， 将需要的数据，按字符串写进指针buf，然后保存xml文件，再读出来，写进别的类任务，将字符串转换为数字，进行计算 #define CONFIG_FILE_CALIB "/root/config/config.xml" using namespace cv; using namespace std; double fishcorrect_value[14]={0,}; class Top//定义了一个大类 { public: explicit Top()
c++操作xml文件
热门推荐
AndyWei147的博客
06-09 1万+
做软件的不会c++，都不好意思说自己是搞软件的。最近也开始慢慢学习c++的东西，今天就写写c++如何操作xml文件吧。我们使用的是tinyxml，有个小巧的库，可以生成和解析XML文档。免费开源，可以直接将源码加到项目中，适合多种平台。他的官方文档为http://sourceforge.net/projects/tinyxml/，可以直接从上面下载相关资源。下载好之后添加到VC项目中...
一个生成和解析XML的c++程序
把握自己。
10-23 2752
首先运用到了tinyxml， 在TinyXML中，根据XML的各种元素来定义了一些类： TiXmlBase：整个TinyXML模型的基类。 TiXmlAttribute：对应于XML中的元素的属性。 TiXmlNode：对应于DOM结构中的节点。 TiXmlComment：对应于XML中的注释 TiXmlDeclaration：对应于XML中的申明部分，即？versiong="1.0"
xml与json互转 C语言实现,C++常用函数之XML JSON格式转换问题
weixin_36364248的博客
05-19 674
数据格式在编程里面很常见，不同的系统都会有自己的标准。因为给有各的定义，每次做第三方开发系统对接的时候数据格式标准都是头疼的事情。在开发过程中比较常见的比如有Json、XML、Key-Value等。这里我们就先看看Json和XML。两者的转换有很多开源的代码可以使用，而且也很完善，可以参考xml2json、xsltjson。XML在Json出现前应用很广泛，灵活性好，应用语言也没有限制，发展了这么...
qt解析xml文件并生成树结构
最新发布
07-09
你可以使用Qt的QXmlStreamReader类来解析XML文件并生成树结构。下面是一个简单的示例代码： ```cpp #include #include #include void parseXmlFile(const QString &filePath, QTreeWidgetItem *parentItem) { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值