Jsoncpp的使用

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。 易于人阅读和编写。同时也易于机器解析和生成。 它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。 这些特性使JSON成为理想的数据交换语言。

JSON建构于两种结构：

• “名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组 （associative array）。
• 值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）。

这些都是常见的数据结构。事实上大部分现代计算机语言都以某种形式支持它们。这使得一种数据格式在同样基于这些结构的编程语言之间交换成为可能。

JSON具有以下这些形式：

对象是一个无序的“‘名称/值’对”集合。一个对象以“{”（左括号）开始，“}”（右括号）结束。每个“名称”后跟一个“:”（冒号）；“‘名称/值’ 对”之间使用“,”（逗号）分隔。

数组是值（value）的有序集合。一个数组以“[”（左中括号）开始，“]”（右中括号）结束。值之间使用“,”（逗号）分隔。

值（value）可以是双引号括起来的字符串（string）、数值(number)、true、false、 null、对象（object）或者数组（array）。这些结构可以嵌套。

字符串（string）是由双引号包围的任意数量Unicode字符的集合，使用反斜线转义。一个字符（character）即一个单独的字符串（character string）。

字符串（string）与C或者Java的字符串非常相似。

数值（number）也与C或者Java的数值非常相似。除去未曾使用的八进制与十六进制格式。除去一些编码细节。

空白可以加入到任何符号之间。 以下描述了完整的语言。

 

C++要使用JSON来解析数据，一般采用jsoncpp. 

网站：http://sourceforge.net/projects/jsoncpp/

下载了之后，解压，然后打开\jsoncpp-src-0.5.0\jsoncpp-src-0.5.0\makefiles\vs71

下的工程文件，进行编译链接就可以得到一个静态链接库json.lib

要用jsoncpp只需要将这个lib文件拷贝到你的工程目录下，并将jsoncpp-src-0.5.0\jsoncpp-src-0.5.0\include\json

复制到工程目录下，然后将这些头文件加到工程中去就可以了。

例子：

{
    "name" : "小楼一夜听春雨",
    "age" : 27
}

[cpp]  view plain  copy

1. #pragma comment(lib, "json_mtd.lib")   
2. #include <fstream>  
3. #include <cassert>  
4. #include "json/json.h"  
5.    
6. int main()  
7. {  
8.     ifstream ifs;  
9.     ifs.open("testjson.json");  
10.     assert(ifs.is_open());  
11.    
12.     Json::Reader reader;  
13.     Json::Value root;  
14.     if (!reader.parse(ifs, root, false))  
15.     {  
16.         return -1;  
17.     }  
18.    
19.     std::string name = root["name"].asString();  
20.     int age = root["age"].asInt();  
21.    
22.     std::cout<<name<<std::endl;  
23.     std::cout<<age<<std::endl;  
24.    
25.     return 0;  
26. }  

[{"name" : "xiaoy", "age" :17} , {"name" : "xiaot", "age" : 20}]

[cpp]  view plain  copy

1. #pragma comment(lib, "json_mtd.lib")  
2.    
3. #include <fstream>  
4. #include <cassert>  
5. #include "json/json.h"  
6.    
7. int main()  
8. {  
9.     ifstream ifs;  
10.     ifs.open("testjson.json");  
11.     assert(ifs.is_open());  
12.    
13.     Json::Reader reader;  
14.     Json::Value root;  
15.     if (!reader.parse(ifs, root, false)){  
16.         return -1;  
17.     }  
18.    
19.     std::string name;  
20.     int age;  
21.     int size = root.size();  
22.     for (int i=0; i<size; ++i)  
23.     {  
24.         name = root[i]["name"].asString();  
25.         age = root[i]["age"].asInt();   
26.         std::cout<<name<<" "<<age<<std::endl;  
27.     }  
28.    
29.     return 0;  
30. }  

　　

json写入：

[cpp]  view plain  copy

1. #pragma comment(lib, "json_mtd.lib")   
2. #include <fstream>  
3. #include <cassert>  
4. #include "json/json.h"   
5.    
6. int main()  
7. {  
8.     Json::Value root;  
9.     Json::FastWriter writer;  
10.     Json::Value person;  
11.    
12.     person["name"] = "hello world";  
13.     person["age"] = 100;  
14.     root.append(person);  
15.    
16.     std::string json_file = writer.write(root);   
17.     ofstream ofs;  
18.     ofs.open("test1.json");  
19.     assert(ofs.is_open());  
20.     ofs<<json_file;  
21.    
22.     return 0;  
23. }  

结果：[{"age":100,"name":"hello world"}]

 

json对数组的解析还支持STL的风格。即

[cpp]  view plain  copy

1. Json::Value::Members member;//Members 这玩意就是vector<string>，typedef了而已  
2. for (Json::Value::iterator itr = objArray.begin(); itr != objArray.end(); itr++)  
3. {  
4.     member = (*itr).getMemberNames();  
5.     for (Json::Value::Members::iterator iter = member.begin(); iter != member.end(); iter++)  
6.     {  
7.         string str_temp = (*itr)[(*iter)].asString();  
8.     }  
9. }  

此种风格与上面的类似，只是上面的只是取"text"节点，而后一种是输出所有节点。

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Jsoncpp简要说明

Jsoncpp的主页上介绍说，Jsoncpp是Json数据格式的编码解码器，提供reader和writer来进行解码和编码。

下面就简要 的介绍Jsoncpp里头的玩意：

1.Reader

该库中的Reader类用来将字串或者流载入解析器。是的后期可以用Reader里面的解析方法来解码Json字串为C++认识的数据。可以用 Json::Reader来声明一个Reader实例。Reader中最常用的就是一个parse方法，该方法用来将载入的json字串解析为C++格式 的数据。

2.Value
这是该库中的核心类，用于存储各样格式的数据，可以包括int,double,short,char *,string,bool,object,array等几乎所有格式的数据。该库的编码和解码的核心功能都是用Value类实现的。就用以上的 Reader的parse方法来说，需要传入一个Value类别的引用值，就是用来存储Json数据的根值，并且可以用这个根值来存取其他的所有值。

3.Writer
这是该库的一个虚类，没有真正的实现encode的功能。需要重载里头的方法来实现真正的encode功能

4.FastWriter
这是该库中真正实现encode功能的类，用来实现将Value编码称为Json串.

我暂时用到的是以上的这些类，该库还提供处理Json字串的注释，提供style来格式化Json字串是的更容易人阅读等功能，这些都没有用到，等 以后用到了再来分享。下面用一段简短的代码来看以上这些Jsoncpp的基本功能:

C++语言:

01 /*
02  this function to encode game/play message
03  !IN
04  token:token string
05  game_id:game id
06  piece_array:piece array
07
08  !OUT
09  encoded json string of game/play message
10
11  !example:
12  token = “asdfasdf”
13  game_id=1;
14  piece_array = [{'A',true,0,1},{'A',true,1,2},{'A',true,2,3},{'A',true,3,4}]
15
16  return:
17  [{"game_id":1,"piece_array":[{"letter":65,"wild":true,"x":0,"y":1},{"letter":65,
18  "wild":true,"x":1,"y":2},{"letter":65,"wild":true,"x":2,"y":3},{"letter":65,"wil
19  d":true,"x":3,"y":4},{"letter":65,"wild":true,"x":4,"y":5}],”token”:”asdfasdf”}]
20  */
21  string encode_game_play_msg( string token , int game_id , vector < piece > piece_array ){
22  Json :: Value root;
23  Json :: Value var;
24
25  //apply “token” and “game_id” value to json struct
26  var [ "token" ] = token;
27  var [ "game_id" ] = game_id;
28
29  Json :: Value pieces; //store all pieces
30  for ( int i = 0; i < piece_array . size(); i ++)
31  {
32  Json :: Value piece_ex; //here it store just one piece
33
34  //next 4 lines to apply piece value to json struct
35  piece_ex [ "letter" ] = piece_array [ i ]. letter;
36  piece_ex [ "wild" ] = piece_array [ i ]. wild;
37  piece_ex [ "x" ] = piece_array [ i ]. x;
38  piece_ex [ "y" ] = piece_array [ i ]. y;
39  pieces . append( piece_ex); //ok,yes we just have apply One piece ,then push back to the array
40  }
41  var [ "piece_array" ] = pieces; //yes,store pieces in var [Value]
42  root . append( var);
43
44  Json :: FastWriter writer;
45  return writer . write( var); //generate json string:),here all is done
46  }

上面这段代码还是相对用到了jsoncpp的大部分编码功能的，用来将数据编码称为json字符串，下面会仔细的分析这段代码

1.首先请看注释中的!IN部分，这是这个函数的传入参数。有三个一个是string类型的token，一个是int类型的game_id，一个是 array，用来存储所有的piece。看!OUT部分就是所要输出的json格式的字符串。用后面的输出可以看到，这个Json字符串中有一个大的根 object，里头有三样东西，1.token,2.game_id,3.piece_array。

2.encode过程
首先之前已经说过，Value在Jsoncpp中是核心类，Reader和Writer都是用Value的功能。以上代码中有[]操作符来赋值给 Value，Value应该是类似一个map结构的数据仓库，用来用树存储所有的数据，最后转换后来编码称为Json格式的字符串。在编码数组的过程中 Value提供了一个append函数用来附加到Value里面，千万记得我前面说过，Value可以直接存数组。当然，Value的[]操作符不能直接 的用数组作为参数，如果能这样就牛了。C++这等编译语言是做不到这么动态的，所以可以看到代码里面其实是Value的嵌套，用Value来实现一个数组 元素的赋值，因为数组元素不是一个简单的编译器支持的内部类型，所以需要解开来赋值。

3.encode
最后直接用FastWriter来实现编码输出，这样一个典型的Jsoncpp的编码Json的过程。

再来看一段解码json串的代码

C++语言:

01 /*
02  this function decode lobby/data return message
03  !example
04  lobby data json string:
05  {\”game\”:{\
06  \”id\”:1,\
07  \”creator_id\”:2,\
08  \”user_max\”:500,\
09  \”template\”:{\”id\”:1},\
10  \”user_array\”:[\
11  {\"id\":1,\"name\":\"test1\"},\
12  {\"id\":2,\"name\":\"test2\"},\
13  {\"id\":3,\"name\":\"test3\"},\
14  {\"id\":4,\"name\":\"test4\"},\
15  {\"id\":5,\"name\":\"test5\"},\
16  {\"id\":6,\"name\":\"test6\"},\
17  {\"id\":7,\"name\":\"test7\"},\
18  {\"id\":8,\"name\":\"test8\"},\
19  {\"id\":9,\"name\":\"test9\"}\
20  ]\
21  }}
22  this function will return a [game_info] structure to be filled by parsed result
23  game_info gi;
24  gi.id -> 1
25  gi.creator_id -> 2
26  gi.user_max -> 500
27  gi.template_r.id -> 1
28  gi.user_array -> [{1,"test1"},{2,"test2"}...] //this is a user_info array to store the game’s users
29  */
30  game_info decode_lobby_data_return_msg( string lobby_data_return_msg ){
31  Json :: Value root;
32  Json :: Reader reader;
33  game_info gi;
34  bool parsedOk  =  false;
35  parsedOk = reader . parse( lobby_data_return_msg , root , false); //decoding…
36  if ( ! parsedOk) //decoded failed
37  {
38  cout << “parsed error! \n “ << reader . getFormatedErrorMessages() << endl;
39  gi . id = - 1000; //game id = -1000,means parsed error!
40  return gi;
41  }
42
43  Json :: Value game = root [ "game" ];
44  /*
45  here three lines are to get value directly by json struct.
46  Json::Value has operator “[]” to get values by key directly,
47  if you want to know more about jsoncpp function,please view document i have send to you
48  */
49  gi . id = game [ "id" ]. asInt();
50  gi . creator_id = game [ "creator_id" ]. asInt();
51  gi . user_max = game [ "user_max" ]. asInt();
52
53  Json :: Value template_r = game [ "template" ];
54  gi . template_r . id = template_r [ "id" ]. asInt();
55
56  Json :: Value users = game [ "user_array" ]; //because user_array is a array ,so we must get its element by [for] circle,please see [for] circle below
57  for ( int index = 0; index < users . size(); index ++)
58  {
59  /*
60  in [for] circle,we must get user_info one by one,and fill in its value by values from json struct,
61  at last,push back into user_array to store the current user_info,then do again
62  */
63  user_info u;
64  u . id = users [ index ][ "id" ]. asInt();
65  u . name = users [ index ][ "name" ]. asString();
66  gi . user_array . push_back( u);
67  }
68
69  return gi;
70  }

这是一段典型的解码json字符串的代码，注释中已经非常明白的写出了该函数的输入和输出，下面简要的分析一下这段代码

1.parse，这个函数在上面的介绍中已经写过，是用来解码字串称为Value格式的数据的函数，然后是要判断函数的返回值，如果返回为 false，那么说明json字串解码错误。

2.当解码成功以后，就是要操作返回的Value值。这里对于如何取Value里头的值，Jsoncpp的Value类提供了两个方法，一个是 get函数，第二个是[]操作符，我个人觉得还是[]好用，传入的参数的json里头的key，你就可以把key所对应的value取出来

3.当提取出来的是数组时，需要逐个提取里面的元素，然后再用Value的转换功能来实现值的提取。Value提供asXXX函数来转换值。