根据给定的 ini 文件和给定的提取节点提取 ini 文件中指定节点的信息

本例子根据给定的 ini 文件名和给定的 ini 节点获取对应节点的信息， 并保存在 _ini_struct 结构体数组中。

点击(此处)折叠或打开

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #include <ctype.h>
   
5. 
   
6. #ifndef SUCCESS
   
7. #define SUCCESS 1
   
8. #endif
   
9. 
   
10. typedef struct _ini_struct {     /* 以 key , value 方式，保存 ini 节点中的节点信息 */
    
11.     char    *key;
    
12.     char    *value;
    
13. } INISTRUST ;
    
14. 
    
15. 
    
16. /* TRIM LEFT */
    
17. 
    
18. int rtrim( char *pszString)
    
19. {
    
20.     int nForwardCursor = 0;
    
21.     int nTrailingCursor = 0;
    
22.     int bTrim = 1;
    
23. 
    
24.     for( nForwardCursor = 0 ; pszString[nForwardCursor] != '\0'; nForwardCursor++ )
    
25.         if ( bTrim && isspace( pszString[nForwardCursor] ))
    
26.             continue ;
    
27.         else {
    
28.             bTrim = 0;
    
29.             pszString[nTrailingCursor] = pszString[nForwardCursor];
    
30.             nTrailingCursor++;
    
31.         }
    
32.     pszString[nTrailingCursor] = '\0';
    
33.     return SUCCESS;
    
34. }
    
35. 
    
36. /* TRIM RIGHT */
    
37. int ltrim( char *pszString )
    
38. {
    
39.     int nForwardCursor = 0;
    
40.     int nTrailingCursor = 0;
    
41.     int bTrim = 1;
    
42.     for ( nForwardCursor=strlen(pszString)-1;
    
43.             nForwardCursor >= 0 && isspace( pszString[nForwardCursor] );
    
44.             nForwardCursor-- )
    
45.     {
    
46.     }
    
47.     pszString[nForwardCursor+1] = '\0';
    
48.     return SUCCESS;
    
49. }
    
50. 
    
51. /* TRIM LEFT & RIGHT */
    
52. int trim(char *str)
    
53. {
    
54.     ltrim(str);
    
55.     rtrim(str);
    
56.     return SUCCESS;
    
57. }
    
58. 
    
59. /* ********************************************************
60.  *  char **read_ini(char *filename , int *iniline )
61.  *        从文件名为 filename 的 ini 文件中读取信息，并将其
62.  *        保存在一个 char *[] 字符串数组中。
63.  *        传入参数：
64.  *            char *filename       一个有效的 ini 文件名
65.  *            int  *iniline       该文件中读取的记录行数
66.  *        返回值：
67.  *            char *[]            保存该 ini 文件的所有记录的
68.  *                                字符串数组
69.  * ******************************************************* */
    
70. char    **read_ini(char *filename,int *iniline)
    
71. {
    
72.     FILE    *fp;
    
73.     char    *str;
    
74.     static char    **ini_str;
    
75.     int    ini_i;
    
76.     int    i,j;
    
77. 
    
78.     ini_str = ( char **)malloc(sizeof(char *));
    
79.     *ini_str = ( char *)malloc(sizeof(char *)*1024);
    
80.     str = ( char *)malloc(sizeof(char)*1024);
    
81. 
    
82.     if ( (fp = fopen(filename,"rb")) != NULL )
    
83.     {
    
84.         ini_i = 0;
    
85.         while(!feof(fp))
    
86.         {
    
87.             bzero(str,1024);
    
88.             if ( fgets(str,1024,fp) != NULL )
    
89.             {
    
90.                 for ( i = 0 ; i < strlen(str); i++ )
    
91.                 {
    
92.                     /* 切掉 ini 文件中的注释信息 */
    
93.                     if ( str[i] == ';' || str[i] == '\n' )
    
94.                     {
    
95.                         str[i] = '\0';
    
96.                     }
    
97.                 }
    
98.                 trim(str);
    
99.                 if ( str[0] != '\0' && str[0] != '\n') {
    
100.                     ini_str[ini_i] = ( char *)malloc(sizeof(char)*1024);
     
101.                     snprintf(ini_str[ini_i],1024,"%s",str);
     
102.                     ini_i++;
     
103.                 }
     
104.             }
     
105.         }
     
106.     }
     
107.     fclose(fp);
     
108.     *iniline = ini_i;
     
109.     return (char **)ini_str;
     
110. }
     
111.  
112. 
     
113. /* *********************************************************************************
114.  *  INISTRUST *get_ini_node ( char *filename , char *nodename,
     
115.  *                            INISTRUST *_sec_node , int *node_size )
116.  *       根据给定的ini文件名和指定的节点 ，提取该文件中指定节点的信息内
117.  *       容，并将其保存在结构体 _ini_struct 数组中
118.  *       传入参数：
119.  *            char *filename           一个有效的 ini 文件的文件名
120.  *            char *nodename           待提取的 ini 文件中的节点名
121.  *            INISTRUST *_sec_node     保存提取到的节点信息的 key，value 结构体数组
122.  *            int *node_size           保存该节点的信息记录条数，一个 key、value 对
123.  *                                     为一条记录
124.  *       返回值：
125.  *           struct *_ini_struct       保存提取的节点的 key、value 键值信息结构数组
126.  * ******************************************************************************* */
     
127. INISTRUST *get_ini_node ( char *filename , char *nodename, INISTRUST *_sec_node , int *node_size )
     
128. {
     
129.     INISTRUST *_ini_node;
     
130.     char    **ini_array;
     
131.     int    ini_line;
     
132.     int    i,j,flag = 0;
     
133.     char    *token;
     
134.     int    i_size = 0;
     
135. 
     
136.     *node_size = 0;
     
137.     _ini_node = _sec_node ;
     
138. 
     
139.     _ini_node = (INISTRUST *)malloc(sizeof(INISTRUST));
     
140.     _ini_node->key = (char *)malloc(sizeof(char)*128);
     
141.     _ini_node->value = (char *)malloc(sizeof(char)*256);
     
142.     ini_array = read_ini(filename,&ini_line);
     
143.     for ( i = 0 ; i< ini_line ; i++ )
     
144.     {
     
145.         if ( ini_array[i][0] == '[' )
     
146.         {
     
147.             if ( strcmp(ini_array[i],nodename)) {
     
148.                 flag = 0;
     
149.                 continue;
     
150.             } else {
     
151.                 flag = 1;
     
152.                 continue;
     
153.             }
     
154.         } else if ( flag == 1 ) {
     
155.             _ini_node[i_size].key = (char *)malloc(sizeof(char)*128);
     
156.             _ini_node[i_size].value = (char *)malloc(sizeof(char)*256);
     
157.             token = strtok(ini_array[i],"=");
     
158.             while( token != NULL )
     
159.             {
     
160.                 if ( j %2 == 0 )
     
161.                 {
     
162.                     snprintf(_ini_node[i_size].key,128,"%s",token);
     
163.                     trim(_ini_node[i_size].key);
     
164.                 } else {
     
165.                     snprintf(_ini_node[i_size].value,256,"%s",token);
     
166.                     trim(_ini_node[i_size].value);
     
167.                 }
     
168.                 token=strtok(NULL,"=");
     
169.                 j++;
     
170.             }
     
171.             i_size++;
     
172.         }
     
173.     }
     
174.     *node_size=i_size;
     
175.     return (INISTRUST *)_ini_node;
     
176. }
     
177. 
     
178. 
     
179. int main ( int argc , char **argv)
     
180. {
     
181.     char    **ini_s;
     
182.     int    ini_line;
     
183.     int    i;
     
184.     INISTRUST *s_ininode = get_ini_node ( argv[1] , argv[2], s_ininode , &ini_line );
     
185.     printf("=== %d \n",ini_line);
     
186.     for ( i = 0 ; i < ini_line ; i++ )
     
187.     {
     
188.         printf(" == KEY = %s \n",s_ininode[i].key);
     
189.         printf(" == VOL = %s \n",s_ininode[i].value);
     
190.     }
     
191. 
     
192.     return 0;
     
193. }

以上是一个完整的从 ini 文件中提取指定节点信息的示例，可以直接使用。
基本实现思路是：
第一步：首先将 ini 文件读取出来，保存在 char *ini_array[] 字符串数组中，在保存的过程中，剔除了注释信息（ini文件中以 ';' 标注注释信息 )，并将每行信息的前后空格剔除。
第二步：将 char *ini_array[] 字符串数组传入 INISTRUCT *_get_ini_node 函数。
第三步：在_get_ini_node 函数中，首先判断每行的首字符是否是 '[' ，如果是，则该行是一个节点名，否则是某个节点下的 key、value, 当找到一个节点名时，对该节点字符串与传入的节点名称进行匹配，如果匹配成功，则将 flag = 1 ，表示下面的行是该节点的 key、value 值，对下面的行使用 strtok 进行拆解，拆解的匹配字符是“=”。然后将拆解的字符串分别存储到 _ini_node[i_size].key 和 _ini_node[i_size].value 中，然后返回到 for 循环中进行下一个判断。

注意事项：
1、此列子中应仔细体会字符串数组 char **ini_str 和结构体 struct _ini_struct *_ini_node 指针的使用方法，尤其是在 get_ini_node 函数中对结构体 struct _ini_struct *_ini_node 指针的两次内存分配操作。
2、本例子中使用了一个小技巧，即在函数 get_ini_node 定义了一个结构体指针 struct _ini_struct *_ini_node , 并将该指针直接指向了传入的结构体指针 struct _ini_struct *_sec_node , 从而实现了直接对 *_sec_node 的操作，实际上，程序没有返回 struct _ini_struct * 时，该程序也可以正常运行，并得到正确的结构，即在 main（）函数中，作如下修改：
            INISTRUCT *s_ininode = get_ini_node ( argv[1] , argv[2] , s_ininode , &iniline);
修改为：
            INISTRUCT *s_ininode;
            get_ini_node ( argv[1] , argv[2] , s_ininode , &iniline);
程序也可以正常运行，并得到正确的结果。
3、iniline 保存的是该节点的 key、value 的记录条数。