最近在一个 C 程序中碰到需要将 XML 数据转换为 JSON 数据的问题，多番查找几种方法，觉得此程序刚好用到了 Linux 下的 libexslt XSLT 库，因此想直接通过 XSLT 将 XML 转为 JSON 数据。

网上已经有了现成的 XML 转 JSON 的 XSLT 程序：

http://code.google.com/p/xml2json-xslt/

下载下来的 xml2json.xslt 程序可以很方便的将标准的 XML 文件转换为 JavaScript 样式的 JSON 数据，但经过试用之后发现此程序还是有一些不足，例如：不支持转换 XML 属性，对数组支持不好等问题。

我对 xml2json.xslt 做了一些改进，包括将 XML 中的属性名转换为 JSON 子节点（节点名称为 @attr 这种特殊的样式），并且为需要明确转换为 JSON 数组的节点（即使该节点下面只包含一个同类的子节点）增加 ifArray 属性，如果 ifArray 属性值为 yes，则在转换为 JSON 强制生成数组。

这个是我修改过的 xml2json.xslt 文件：

https://gist.github.com/zohead/9688858

Linux 系统可以方便的使用 xsltproc 命令将 XML 转换为 JSON，运行下面的命令就会直接将转换出来的 JSON 数据打印到标准输出中：

xsltproc xml2json.xslt test.xml

下面主要介绍如何在 Linux 中编程使用 libexslt 库将 XML 转换为 JSON 数据，有关 libexslt 库的介绍请参考这里：http://xmlsoft.org/libxslt/EXSLT/，可惜 libexslt 并没有详细的介绍文档，连网上的例子都很少。

这个是我的 xslt.c 实例程序：

#include <string.h>
#include <libxml/xmlmemory.h>
#include <libxml/debugXML.h>
#include <libxml/HTMLtree.h>
#include <libxml/xmlIO.h>
#include <libxml/xinclude.h>
#include <libxml/catalog.h>
#include <libxml/parser.h>
#include <libxml/parserInternals.h>
#include <libxml/uri.h>
#include <libxslt/xslt.h>
#include <libxslt/xsltInternals.h>
#include <libxslt/transform.h>
#include <libxslt/xsltutils.h>
#include <libexslt/exslt.h>
#include <libexslt/exsltconfig.h>
#include <libexslt/exsltexports.h>

int xslProc(const char *xslfile, const char *xmlfile, const char *outfile, const char *xmlstr, char *lpbuf, size_t bufsize)
{
	xsltStylesheetPtr cur = NULL;
	xmlDocPtr doc = NULL, res = NULL;
	int iRet = -1;

	if (xslfile == NULL || !xslfile[0] || ((xmlfile == NULL || !xmlfile[0]) && (xmlstr == NULL || !xmlstr[0])) || ((outfile == NULL || !outfile[0]) && lpbuf == NULL))
		return -1;

	exsltRegisterAll();
	xmlInitParser();
	xmlSubstituteEntitiesDefault(1);
	xmlLoadExtDtdDefaultValue = 1;

	cur = xsltParseStylesheetFile((const xmlChar *)xslfile);
	if (cur) {
		if (xmlfile)
			doc = xmlParseFile(xmlfile);
		else
			doc = xmlParseMemory(xmlstr, strlen(xmlstr));
		if (doc) {
			res = xsltApplyStylesheet(cur, doc, NULL);
			if (res) {
				if (outfile)
					iRet = xsltSaveResultToFilename(outfile, res, cur, 0);
				else {
					char *out = NULL;
					int outlen = 0;
					iRet = xsltSaveResultToString((xmlChar **)&out, &outlen, res, cur);
					if (out) {
						if (iRet == 0) strncpy(lpbuf, out, bufsize);
						free(out);
					}
				}
				xmlFreeDoc(res);
			} else
				iRet = 1;
			xmlFreeDoc(doc);
		} else
			iRet = 2;
		xsltFreeStylesheet(cur);
	} else
		iRet = 3;

	xsltCleanupGlobals();
	xmlCleanupParser();

	return iRet;
}

程序传入 XSLT 文件名，支持 XML 字符串、XML 文件以及输出到文件及保存到字符串的方式。

具体实现方法还是比较简单的，使用 Linux 的 libexslt 库解析 XSLT 文件（xsltParseStylesheetFile），libxml 库来解析 XML 文件（xmlParseFile 和 xmlParseMemory 函数），使用 libexslt 库应用 XSLT stylesheet（xsltApplyStylesheet），保存结果数据使用 xsltSaveResultToFilename 和 xsltSaveResultToString 函数，程序中需要特别注意的就是 libxml 和 libexslt 库中众多的初始化和释放操作。

STL中的容器类（Container）一般提供了4个迭代器：iterator、const_iterator、reverse_iterator、const_reverse_iterator，对于 container<T> 而言，其中 const_iterator 相当于 const T *，const_iterator 指向的元素不能做修改操作。

STL 容器的 begin() 和 end() 默认都提供了 iterator 和 const_iterator 的迭代器，相应的 rbegin() 和 rend() 则也分别提供了 reverse_iterator 和 const_reverse_iterator 的迭代器用于从容器的尾端反向遍历。

最近写的代码中刚好要用到 const_iterator 迭代器，发现由于 STL 提供的一些容器操作函数像 insert、erase 的参数必须为 iterator，这时就不能用 const_iterator 做参数（不能直接转换），以下为个人经验结果。

1、const_iterator 转换为 iterator：

iterator 可以隐式转换为 const_iterator，但反过来就不行，就算祭出强制类型转换的杀招应该也会编译报错，这是可以用折中的办法解决：

vector<sss> v_test;
vector<sss>::iterator i_test;
vector<sss>::const_iterator c_test;
...
c_test = ....
...
i_test = v_test.begin();
advance(i_test, distance<vector<sss>::const_iterator>(i_test, c_test));

i_test 指向第一个元素，先通过 distance 得到 c_test 和 i_test 的偏移量，然后用 advance 将 i_test 往后移对应的偏移量即可。注意 distance 的模板类型必须为 const_iterator 类型，否则按照 STL 的默认类型推导，distance 中的 i_test 和 c_test 类型不同还是会出现编译报错。

当然如果你想偷懒简单点，也可以这样写，道理是一样的，这时类型推导就显得很好用了：

i_test = v_test.begin() + (c_test - v_test.begin());

2、reverse_iterator 转换为 iterator：

对于 reverse_iterator 可以调用 base() 得到 “与之对应” 的 iterator（与上面的环境一样）：

vector<sss> v_test;
vector<sss>::iterator i_test;
vector<sss>::reverse_iterator r_test;
...
r_test = ....
...
i_test = r_test.base();

但需要注意的是由于 STL 的 begin() 和 end()、rbegin() 和 rend() 是两个半闭合的区间，end() 并不是最后一个元素，rend() 也不是第一个元素，因此 end() 和 rbegin()、rend() 和 begin() 之间都是差了一个元素的。我们来看看 STL 标准上 base() 的说明：

The base iterator is an iterator of the same type as the one used to construct the reverse_iterator, but pointing to the element next to the one the reverse_iterator is currently pointing to (a reverse_iterator has always an offset of -1 with regards to its base iterator).

也就是 reverse_iterator 的 base() 返回的元素都是 reverse_iterator 所指向元素的下一个元素，这也是前面 “与之对应” 加引号的原因。因此在使用时要特别注意，例如如果要删除 reverse_iterator 指向的元素就需要这样（因为 erase 必须要 iterator 类型的参数）：

v_test.erase((++r_test).base());

3、关于随机访问容器：

STL 中随机访问容器是一个迭代器类型为随机访问迭代器的可逆容器，它提供常量缓冲时间来访问随机元素。而可逆容器是一个有双向迭代器的前向容器，它可以向后向后迭代通过容器。

常用到的顺序容器是将单一类型的元素聚集起来，然后根据位置来存储和访问这些元素。顺序容器的元素排列次序与元素值无关，而是由元素添加到容器里的次序决定。

平时经常用的 string、vector、deque 之类就是典型的随机访问容器，map、set、list 之类的就不是。

因此需要注意 STL 中的 sort 等函数的参数必须是随机访问迭代器，所以对 map、set、list 等容器是无效的。

以上为个人见解，有任何问题欢迎指正交流咯 ^_^。

在使用 STL 的 find_if、count_if 等函数时会发现这些函数使用的参数不是普通的函数指针，而是 functional 函数对象，实际使用函数对象时可以自己定义一个仿函数来实现（实现带参数的 operator () 即可），这个相对比较简单就不写出来了。但有些情况需要直接使用普通的二元函数指针，这时可以使用 ptr_fun 将函数指针转换为函数对象作为 find_if、count_if 等的参数。

先看一个能正常工作的二元函数不使用引用类型参数的代码：

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std;

class sss
{
public:
	explicit sss(int val) : value(val) {}

	sss(const sss& org)
	{
		cout << "---copy " << &org << " to " << this << endl;
		value = org.value;
	}

	virtual ~sss() {}

	int value;
};

bool find_sss(sss s_chk, int val)
{
	bool ret = (s_chk.value == val);
	s_chk.value = 222;
	return ret;
}

int main(int argc, char ** argv)
{
	vector<sss> vvv;
	vector<sss>::iterator iii;

	vvv.push_back(sss(11));
	vvv.push_back(sss(12));
	vvv.push_back(sss(13));
	vvv.push_back(sss(14));
	vvv.push_back(sss(15));

	cout << "before find_if" << endl;
	iii = find_if(vvv.begin(), vvv.end(), bind2nd(ptr_fun(find_sss), 13));

	if (iii == vvv.end())
		cout << "not found" << endl;
	else
		cout << "index: " << (iii - vvv.begin()) << ", value: " << iii->value << endl;

	return 0;
}

程序很简单，从 vector 中查找符合条件的 sss 对象，find_sss 就是要转换的二元函数指针，第一个参数是 sss 类，通过 ptr_fun 可以使本代码正常工作。

通过下面的运行输出能看出调用 find_sss 时进行了拷贝构造（本程序的编译环境为：Windows 7 32bit, Mingw gcc 3.4.5，Visual Studio 2010中稍有不同，主要在前面的拷贝次数上）：

---copy 0x22ff10 to 0x552a58
---copy 0x552a58 to 0x552ad8
---copy 0x22ff10 to 0x552ae0
---copy 0x552ad8 to 0x552af0
---copy 0x552ae0 to 0x552af8
---copy 0x22ff10 to 0x552b00
---copy 0x22ff10 to 0x552b08
---copy 0x552af0 to 0x552b18
---copy 0x552af8 to 0x552b20
---copy 0x552b00 to 0x552b28
---copy 0x552b08 to 0x552b30
---copy 0x22ff10 to 0x552b38
before find_if
---copy 0x552b18 to 0x22fdd0
---copy 0x22fdd0 to 0x22fd40
---copy 0x552b20 to 0x22fdd0
---copy 0x22fdd0 to 0x22fd40
---copy 0x552b28 to 0x22fdd0
---copy 0x22fdd0 to 0x22fd40
index: 2, value: 13

接下来就是实际碰到的问题了，如果将 find_sss 的第一个参数改为 sss 的引用，即第 24 行改为：

bool find_sss(sss& s_chk, int val)

上面的代码就会编译出错（以 Visual Studio 2010 的错误输出为例）：

C:\Program Files\Microsoft Visual Studio 10.0\VC\INCLUDE\xfunctional(341) : error C2535: “bool std::binder2nd<_Fn2>::operator ()(sss &) const”: 已经定义或声明成员函数
with
[
_Fn2=std::pointer_to_binary_function<sss &,int,bool,bool (__cdecl *)(sss &,int)>
]
C:\Program Files\Microsoft Visual Studio 10.0\VC\INCLUDE\xfunctional(335) : 参见“std::binder2nd<_Fn2>::operator ()”的声明
with
[
_Fn2=std::pointer_to_binary_function<sss &,int,bool,bool (__cdecl *)(sss &,int)>
]
test.cpp(43): 参见对正在编译的类 模板 实例化“std::binder2nd<_Fn2>”的引用
with
[
_Fn2=std::pointer_to_binary_function<sss &,int,bool,bool (__cdecl *)(sss &,int)>
]

网上的码农和攻城师们基本都认为是 STL 本身的问题，传递引用类型参数会造成 reference to reference 问题。

几番尝试之后，发现的解决方法如下：

1、Visual Studio 2010下的不完美解决方法：

将第 43 行改为：

    iii = find_if(vvv.begin(), vvv.end(), bind2nd(pointer_to_binary_function<sss, int, bool, bool(*)(sss&, int)>(find_sss), 13));

这样通过自己给 pointer_to_binary_function 设置模板参数避免编译出错，实际运行中会发现 find_if 查找可以正常工作了，但第 27 行中修改引用类的值会没有效果，因为这种方式不是真正的引用，仍然有拷贝构造，由于需要用到这些二元函数的场合一般不需要修改数据，使用起来没有太大问题。

2、gcc下的不完美解决方法：

如果 gcc 下用上面的改动，你会发现由于 gcc 下 pointer_to_binary_function 只有 3 个参数，无法顺利修改编译，但可以这样折中，将第 43 行改为：

    iii = find_if(vvv.begin(), vvv.end(), bind2nd(ptr_fun((bool(*)(sss, int)) find_sss), 13));

通过强制类型转换来实现，稍显恶心，查找可以正常工作，但依然是拷贝构造。需要注意此方法如果在 Visual Studio 中使用会出错。

3、终极解决方案- 使用 boost 库：

首先头文件中增加：

#include <boost/functional.hpp>

然后原来的第 43 行改为：

    iii = find_if(vvv.begin(), vvv.end(), boost::bind2nd(boost::ptr_fun(find_sss), 13));

编译运行之后发现 find_if 查找可以正常工作，而且现在是真正的引用，只能说 boost 的 functional 相比 STL 的实在是好强大，哈哈。

运行输出如下（使用 Mingw gcc 3.4.5 编译），find_if 找到的值已经被 find_sss 修改：

---copy 0x22ff10 to 0x7f2a58
---copy 0x7f2a58 to 0x7f2ad8
---copy 0x22ff10 to 0x7f2ae0
---copy 0x7f2ad8 to 0x7f2af0
---copy 0x7f2ae0 to 0x7f2af8
---copy 0x22ff10 to 0x7f2b00
---copy 0x22ff10 to 0x7f2b08
---copy 0x7f2af0 to 0x7f2b18
---copy 0x7f2af8 to 0x7f2b20
---copy 0x7f2b00 to 0x7f2b28
---copy 0x7f2b08 to 0x7f2b30
---copy 0x22ff10 to 0x7f2b38
before find_if
index: 2, value: 222

以上仅为个人小心得，有任何问题欢迎指正，玩的开心咯 ^_^

在C++的某些应用环境中，如果有多个派生类同时继承同一个基类，但只要想基类成员的一份拷贝，这样可以把对基类的继承声明为虚拟（virtual）的，以达到需要的目的，用 virtual 限定的继承即为虚继承，对应的基类即为虚基类，没有则为非虚基类。在派生类产生的对象中，同名的虚基类只产生一个虚基类对象，非虚基类则有各自的对象，需要注意虚基类和抽象类的区分。

另外特别需要注意的是一个基类即可以被用作虚基类，也可以被用作非虚基类，这纯粹看是否是虚继承（是否有 virtual 限定）。虚基类子对象是由最远派生类（也就是建立对象时所指定的类）的构造函数调用虚基类的构造函数进行初始化。如果一个派生类继承了多个基类，其中既有虚基类，也有非虚基类，则虚基类构造函数优先于非虚基类的构造函数，而不管实际书写顺序，而且如果该派生类的构造函数初始化列表中同时有对虚基类和非虚基类构造函数的调用，同样也是虚基类优先。

有关虚基类的其它说明请参考其它书籍咯，下面是测试的代码：

#include <iostream>

using namespace std;

class Base
{
public:
	explicit Base(int val) : value(val)
	{
		cout << "init Base " << this << ", value:" << value << endl;
	}

	~Base()
	{
		cout << "destory Base " << this << ", value:" << value << endl;
	}

private:
	int value;
};

class Base2 : public virtual Base
{
public:
	Base2(int val) : Base(val)
	{
		cout << "init Base2" << endl;
	}
};

class Base3 : public virtual Base
{
public:
	Base3(int val) : Base(val)
	{
		cout << "init Base3" << endl;
	}
};

class Base4 : public Base2, public virtual Base3
{
public:
	Base4(int val) : Base2(val), Base3(val), Base(val)
	{
	}
};

int main(int argc, char ** argv)
{
	Base4 base_4(22);

	return 0;
}

比较简单，Base2 和 Base3 分别派生自 Base，而且都是虚继承，Base4 同时派生自 Base2 和 Base3，但 Base3 前有 virtual，表示 Base4 对 Base3 是虚继承，Base4 对 Base2 是非虚继承。另外代码中比较特殊的一点是 Base 基类中去掉了默认构造函数，改为一个 int 参数的构造函数（第 8 行），因此 Base2 和 Base3 的构造函数的初始化列表中都需要增加对基类 Base 构造函数的调用，同样 Base4 需要调用 Base、Base2 和 Base3。
主程序中只是生成一个 Base4 的对象，上述代码的运行输出为：
init Base 0x22ff34, value:22

	init Base3

	init Base2

	destory Base 0x22ff34, value:22

	
由上面的输出可以验证虚基类的概念：
由于 Base2 和 Base3 都是对 Base 的虚继承，虽然 Base4 中分别调用了 Base2 和 Base3 的构造函数，但虚继承就表示基类 Base 只有一份拷贝，Base 只需要构造一次。另外由于 Base4 对 Base2 是非虚继承，对 Base3 是虚继承，尽管 Base2 看起来在前面调用，但由于 Base3 对 Base4 是虚基类，它的构造函数就需要先于 Base2 对调用，因此 ”init Base3“ 在 ”init Base2“ 前面。
接着对代码稍作改动，将 Base2 和 Base3 都改为非虚继承，Base4 中去掉对 Base 基类构造函数的调用：
第22行：class Base2 : public Base

	第31行：class Base3 : public Base

	第43行：    Base4(int val) : Base2(val), Base3(val)

	
编译运行输出，结果为：
init Base 0x22ff38, value:22

	init Base3

	init Base 0x22ff34, value:22

	init Base2

	destory Base 0x22ff34, value:22

	destory Base 0x22ff38, value:22

	
可以看到由于 Base2 和 Base3 都不是非虚继承，Base 就被构造了两次。
在上面的基础上再做个小改动，把 Base4 对 Base3 的派生也改为非虚继承：
第40行：class Base4 : public Base2, public Base3

	
再次运行输出，结果即为：
init Base 0x22ff30, value:22

	init Base2

	init Base 0x22ff34, value:22

	init Base3

	destory Base 0x22ff34, value:22

	destory Base 0x22ff30, value:22

	
由于 Base4 对 Base2 和 Base3 都不是虚继承了，对 Base2 和 Base3 的构造函数调用就按实际顺序了。
这样虚基类的概念就算是比较清楚咯。 ^_^
]]>
			https://zohead.com/archives/cplusplus-virtual-base-class/feed/
		0
		
		
		
		https://zohead.com/archives/vector-push-back-space-copy/
		https://zohead.com/archives/vector-push-back-space-copy/#comments
		Fri, 04 May 2012 18:30:56 +0000
		
				
		
		
		
		
		
		
		

		http://zohead.com/?p=104
		
				本文同步自：https://zohead.com/archives/vector-push-back-space-copy/

这两天在实际程序中使用 STL 的 vector push_back 类对象时出现问题，偶尔发现 vector 在 push_back 时的调用类对象的拷贝构造函数和析构函数有点特别，简单做下分析。
程序代码：
#include <iostream>
#include <vector>

using namespace std;

struct sss
{
public:
	explicit sss(int val) : value(val)
	{
		cout << "---init sss " << this << ", value:" << value << endl;
	}

	sss(const sss& org)
	{
		cout << "---copy " << &org << " to " << this << endl;
		value = org.value;
	}

	~sss()
	{
		cout << "---destory sss " << this << ", value:" << value << endl;
	}
 
	int value;
};

int main(int argc, char ** argv)
{
	sss s_tmp(11);
	int i = 0;
	vector<sss> vvv;

	for (i = 0; i < 5; i++) {
		s_tmp.value++;
		vvv.push_back(s_tmp);
		cout << "size: " << vvv.size() << ", capacity: " << vvv.capacity() << endl;
	}

	return 0;
}


功能很简单，main 中定义一个 sss 类对象和对应的 vector，然后在循环中改类成员的值，并依次 push_back 到 vector 中，类的构造函数、析构函数、拷贝构造函数中都加了对应的打印输出。循环运行了5次，往 vector 中增加了5个类成员。
实际运行输出如下：

---init sss 0x22ff20, value:11
 ---copy 0x22ff20 to 0x5d2a58
 size: 1, capacity: 1
 ---copy 0x5d2a58 to 0x5d2ad8
 ---copy 0x22ff20 to 0x5d2adc
 ---destory sss 0x5d2a58, value:12
 size: 2, capacity: 2
 ---copy 0x5d2ad8 to 0x5d2ae8
 ---copy 0x5d2adc to 0x5d2aec
 ---copy 0x22ff20 to 0x5d2af0
 ---destory sss 0x5d2ad8, value:12
 ---destory sss 0x5d2adc, value:13
 size: 3, capacity: 4
 ---copy 0x22ff20 to 0x5d2af4
 size: 4, capacity: 4
 ---copy 0x5d2ae8 to 0x5d2b00
 ---copy 0x5d2aec to 0x5d2b04
 ---copy 0x5d2af0 to 0x5d2b08
 ---copy 0x5d2af4 to 0x5d2b0c
 ---copy 0x22ff20 to 0x5d2b10
 ---destory sss 0x5d2ae8, value:12
 ---destory sss 0x5d2aec, value:13
 ---destory sss 0x5d2af0, value:14
 ---destory sss 0x5d2af4, value:15
 size: 5, capacity: 8
 ---destory sss 0x5d2b00, value:12
 ---destory sss 0x5d2b04, value:13
 ---destory sss 0x5d2b08, value:14
 ---destory sss 0x5d2b0c, value:15
 ---destory sss 0x5d2b10, value:16
 ---destory sss 0x22ff20, value:16

结果分析：
 
vector 每次调用 push_back 时都会拷贝一个新的参数指定的 sss 类对象，这会调用 sss 的拷贝构造函数，第一次的 copy 正常，而且 vector 的实际容量也由 0  变为 1。
第二次调用 push_back，通过输出会发现调用了两次拷贝构造函数，一次析构函数，原来 vector 此时判断容量不够，将容量扩大为原来的两倍，变为 2，并将原来的元素再次拷贝一份存放到新的内存空间，然后拷贝新加的类对象，最后再释放原来的元素。
第三次调用 push_back 时，vector 自动扩大为4，因此拷贝构造函数调用了3次，析构函数调用了2次，程序最终退出了时就析构了 5 次加本身的 sss 类对象一共 6 次。
参考：
由此看来，vector 的 push_back 在发现空间不足时自动将空间以 2 的指数增长：0 -> 1 -> 2 -> 4 -> 8 -> 16 -> 32 ...
查找资料后得知，如此设计的主要目的是为了尽可能的减小时间复杂度；如果每次都按实际的大小来增加 vector 的空间，会造成时间复杂度很高，降低 push_back 的速度。
另外关于 push_back 为什么会执行拷贝构造函数，push_back 的原型为：
void push_back(const _Ty& _Val)
参数是以引用方式传递，按说不会拷贝，但 push_back 实际实现中判断空间不足时是调用 insert 函数添加元素：
void push_back(const _Ty& _Val)
 {
    // insert element at end
    if (size() < capacity())
    #if _HAS_ITERATOR_DEBUGGING
    {
       // room at end, construct it there
       _Orphan_range(_Mylast, _Mylast);
       _Mylast = _Ufill(_Mylast, 1, _Val);
    }
    #else /* _HAS_ITERATOR_DEBUGGING */
       _Mylast = _Ufill(_Mylast, 1, _Val);
    #endif /* _HAS_ITERATOR_DEBUGGING */
    else
       insert(end(), _Val);
 }
更新：
2012-05-10：
近期在 Visual Studio 2010 中发现 vector 的实际空间增加顺序为：1 - 2 - 3 - 4 - 6 - 9 - 13 - 19 - 28 - 42 - 63 - 94 - 141 - 211 ...，有空时再继续研究。
以上只是个人粗略分析，有任何问题欢迎指正，玩的开心咯 ^_^
]]>
			https://zohead.com/archives/vector-push-back-space-copy/feed/
		2