如何分割如下的字符串？

凌风剑

各位大佬帮忙看下，如下的字符串：
std::string sub_property="{C_USER_NETWORK_TYPE=0,C_SUB_SALT=89EE043854C7ACCE,C_SMSAlertsFlag=1,C_IS_GROUP_MEMBER=0,C_MBB_NOTIFY_FLAG=2}";

字符串里面保存了用户的相关属性和属性的取值，各个属性以逗号分开，等号左边为参数名称， 右边为参数取值，我想取每个参数和对应的取值，例如参数C_USER_NETWORK_TYPE的取值为0，C_SUB_SALT的取值为89EE043854C7ACCE等等，并且属性的多少根据用户类型的不同也是不一样的

考虑每个字段都是键值的集合，因此把参数和取值放到map容器里面，但是如何能取到每个参数和对应的取值的？

凌风剑

这里好冷清啊，半天都没人回答，也罢，自己胡乱写了一个，也许性能不高，凑合着用吧

1. void getSubProperty(const std::string &origin_str,std::map<std::string,std::string> &tmap)
   
2. {
   
3.         /*输入字段：{C_USER_NETWORK_TYPE=0,C_SUB_SALT=89EE043854C7ACCE,C_SMSAlertsFlag=1,C_IS_GROUP_MEMBER=0,C_MBB_NOTIFY_FLAG=2}*/
   
4. 
   
5. /*首先去除字符串最左边的{和最右边的}符号*/

复制代码

bruceteen

1. #include <iostream>
   
2. #include <string>
   
3. 
   
4. bool foo( const std::string& s )
   
5. {
   
6.     static const std::string whitespace = "\t\n\v\f\r "; // 空白字符
   
7. 
   
8.     struct // 去除字符串两端的空白字符
   
9.     {
   
10.         std::string operator()( const std::string& s, size_t left, size_t right ) const
    
11.         {
    
12.             left = s.find_first_not_of( whitespace, left );
    
13.             if( left==std::string::npos || left>=right )
    
14.                 return std::string();
    
15.             right = s.find_last_not_of(whitespace,right-1)+1;
    
16.             return s.substr(left,right-left);
    
17.         }
    
18.     } trim;
    
19. 
    
20.     // 找到首部第一个非空字符
    
21.     size_t left = s.find_first_not_of( whitespace );
    
22.     if( left==std::string::npos || s[left]!='{' )
    
23.         return false;
    
24.     ++left;
    
25. 
    
26.     // 找到尾部第一个非空字符
    
27.     size_t right = s.find_last_not_of( whitespace );
    
28.     if( right==std::string::npos || s[right]!='}' )
    
29.         return false;
    
30. 
    
31.     for( ; left<right; )
    
32.     {
    
33.         size_t commasign = s.find( ',', left ); // 以逗号分割
    
34.         if( commasign == std::string::npos )
    
35.             commasign = right;
    
36.         {
    
37.             size_t equalsign = s.find( '=', left ); // 以等号分割
    
38.             if( equalsign==std::string::npos || equalsign>=commasign ) // 没有找到等号
    
39.             {
    
40.                 std::cout << '\"' << trim(s,left,commasign) << '\"' << '\n';
    
41.             }
    
42.             else
    
43.             {
    
44.                 std::cout << '\"' << trim(s,left,equalsign) << '\"' << " = " << '\"' << trim(s,equalsign+1,commasign) << '\"' << '\n';
    
45.             }
    
46.         }
    
47.         left = commasign+1;
    
48.     }
    
49. 
    
50.     return true;
    
51. }
    
52. 
    
53. int main( void )
    
54. {
    
55.     //std::string sub_property = "{C_USER_NETWORK_TYPE=0,C_SUB_SALT=89EE043854C7ACCE,C_SMSAlertsFlag=1,C_IS_GROUP_MEMBER=0,C_MBB_NOTIFY_FLAG=2}";
    
56.     std::string sub_property = "{ a=0, b = 1 , c=, =3, , f }";
    
57.     foo( sub_property );
    
58. }

复制代码

输出

"a" = "0"
"b" = "1"
"c" = ""
"" = "3"
""
"f"

dorodaloo

也胡乱写了一个

prop = C_USER_NETWORK_TYPE      val = 0
prop = C_SUB_SALT       val = 89EE043854C7ACCE
prop = C_SMSAlertsFlag  val = 1
prop = C_IS_GROUP_MEMBER        val = 0
prop = C_MBB_NOTIFY_FLAG        val = 2

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. #define SIZE 32
   
6. typedef struct {
   
7.     char prop[SIZE];
   
8.     char val[SIZE];
   
9. } Map;
   
10. 
    
11. void scan(char *, Map **, unsigned *);
    
12. int main() {
    
13.    
    
14.     /* STRING */
    
15.     char property[] = "{C_USER_NETWORK_TYPE=0,C_SUB_SALT=89EE043854C7ACCE,C_SMSAlertsFlag=1,C_IS_GROUP_MEMBER=0,C_MBB_NOTIFY_FLAG=2}";
    
16.    
    
17.     /* MAP */
    
18.     Map *map = NULL;
    
19.     unsigned size = 0;
    
20. 
    
21.     /* SCAN */
    
22.     scan(property, &map, &size);
    
23. 
    
24.     /* TEST */
    
25.     for (int i = 0; i < size; i++) {
    
26.         printf("prop = %s\tval = %s\n", map[i].prop, map[i].val);
    
27.     }
    
28.    
    
29.     /* FREE */
    
30.     free(map);
    
31. }
    
32. 
    
33. void scan(char *property, Map **map, unsigned *size) {
    
34.     char *p = property;
    
35.     while (*p) if (*p++ == '=') ++*size;
    
36.     *map = malloc(*size * sizeof(Map));
    
37.     unsigned idx = 0;
    
38.     p = property + 1;
    
39.     p = strtok(p, ",");
    
40. 
    
41.     while (p) {
    
42.         sscanf(p, "%[^=]=%[^}]", (*map)[idx].prop, (*map)[idx].val);
    
43.         idx++;
    
44.         p = strtok(NULL, ",");
    
45.     }
    
46. }
    

复制代码

dorodaloo

凑合凑合着用吧

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. #define SIZE 32
   
6. typedef struct Map {
   
7.     char prop[SIZE];
   
8.     char val[SIZE];
   
9.     struct Map *next;
   
10. } Map;
    
11. 
    
12. Map *scan(char *);
    
13. void insert(Map **, Map *);
    
14. void destroy(Map *);
    
15. 
    
16. int main(void) {
    
17.     char property[] =    "{C_USER_NETWORK_TYPE=0,C_SUB_SALT=89EE043854C7ACCE,C_SMSAlertsFlag=1,C_IS_GROUP_MEMBER=0,C_MBB_NOTIFY_FLAG=2}";
    
18. 
    
19.     Map *map = scan(property);
    
20. 
    
21.     /* TEST */
    
22.     for (Map *e = map; e; e = e->next) {
    
23.         printf("prop = %s\tval = %s\n", e->prop, e->val);
    
24.     }
    
25. 
    
26.     destroy(map);
    
27. }
    
28. 
    
29. Map *scan(char *property) {
    
30.     Map *map = NULL;
    
31.     char *p = strtok(property + 1, ",");
    
32. 
    
33.     while (p) {
    
34.         Map *e = malloc(sizeof(Map));
    
35.         sscanf(p, "%[^=]=%[^}]", e->prop, e->val);
    
36.         insert(&map, e);
    
37.         p = strtok(NULL, ",");
    
38.     }
    
39.     return map;
    
40. }
    
41. 
    
42. void insert(Map **m, Map *e) {
    
43.     e->next = *m;
    
44.     *m = e;
    
45. }
    
46. 
    
47. void destroy(Map *m) {
    
48.     if (m->next) destroy(m->next);
    
49.     free(m);
    
50. }
    

复制代码

yulihua49

凌风剑 发表于 2018-01-23 17:51
各位大佬帮忙看下，如下的字符串：
std::string sub_property="{C_USER_NETWORK_TYPE=0,C_SUB_SALT=89EE04 ...

发送与接收的字节数必须严格相等。

yulihua49

凌风剑 发表于 2018-01-23 17:51
各位大佬帮忙看下，如下的字符串：
std::string sub_property="{C_USER_NETWORK_TYPE=0,C_SUB_SALT=89EE04 ...

先用strtok分解,为各个子串。
分别对每个子串，对等号进行拆分，分为左部和右部。这个拆分可以使用strtok或正则表达式。

cobras

给个纯C的解决方案：

1. 
   
2. #include <string.h>
   
3. #include <stdlib.h>
   
4. #include <stdio.h>
   
5. 
   
6. struct key_value_node
   
7. {
   
8.         struct key_value_node *previous, *next;
   
9.         int key_offset, key_limit;
   
10.         int value_offset, value_limit;
    
11. };
    
12. 
    
13. int nstrchr(const char *s, int off, int lmt, int *o_off, int chr)
    
14. {
    
15.         for (off; off < lmt; ++off) {
    
16.                 if (s[off] == chr) {
    
17.                         if (o_off != NULL) {
    
18.                                 *o_off = off;
    
19.                         }
    
20.                         return 0;
    
21.                 }
    
22.         }
    
23.         return -1;
    
24. }
    
25. 
    
26. int skip_text(const char *s, int off, int lmt, int *o_off, const char *text, int text_len)
    
27. {
    
28.         if (off + text_len <= lmt) {
    
29.                 if (strncmp(s + off, text, text_len) == 0) {
    
30.                         if (o_off != NULL) {
    
31.                                 *o_off = off + text_len;
    
32.                         }
    
33.                         return 0;
    
34.                 }
    
35.         }
    
36.         return -1;
    
37. }
    
38. 
    
39. int skip_until_text(const char *s, int off, int lmt, int *o_off, const char *text, int text_len)
    
40. {
    
41.         if (off + text_len <= lmt && strncmp(s + off, text, text_len) != 0) {
    
42.                 do {
    
43.                         ++off;
    
44.                 }while (off + text_len <= lmt && strncmp(s + off, text, text_len) != 0);
    
45.                 if (o_off != NULL) {
    
46.                         *o_off = off + text_len;
    
47.                 }
    
48.                 return 0;
    
49.         }
    
50.         return -1;
    
51. }
    
52. 
    
53. int skip_charset(const char *s, int off, int lmt, int *o_off, const char *text, int text_len)
    
54. {
    
55.         int i;
    
56. 
    
57.         if (off < lmt && nstrchr(text, 0, text_len, &i, s[off]) == 0) {
    
58.                 do {
    
59.                         ++off;
    
60.                 }while (off < lmt && nstrchr(text, 0, text_len, &i, s[off]) == 0);
    
61.                 if (o_off != NULL) {
    
62.                         *o_off = off;
    
63.                 }
    
64.                 return i;
    
65.         }
    
66.         return -1;
    
67. }
    
68. 
    
69. int skip_until_charset(const char *s, int off, int lmt, int *o_off, const char *text, int text_len)
    
70. {
    
71.         int i;
    
72. 
    
73.         if (off < lmt && nstrchr(text, 0, text_len, &i, s[off]) != 0) {
    
74.                 do {
    
75.                         ++off;
    
76.                 }while (off < lmt && nstrchr(text, 0, text_len, &i, s[off]) != 0);
    
77.                 if (o_off != NULL) {
    
78.                         *o_off = off;
    
79.                 }
    
80.                 return i;
    
81.         }
    
82.         return -1;
    
83. }
    
84. 
    
85. int free_key_value_table(struct key_value_node *table)
    
86. {
    
87.         struct key_value_node *node, *node_temp;
    
88. 
    
89.         if (table != NULL) {
    
90.                 node = table;
    
91.                 do {
    
92.                         node_temp = node;
    
93.                         node = node->next;
    
94.                         free(node_temp);
    
95.                 }while (node != table);
    
96.         }
    
97.         return 0;
    
98. }
    
99. 
    
100. struct key_value_node *get_key_value_table(const char *text, int text_len)
     
101. {
     
102.         struct key_value_node *table, *node;
     
103.         int off;
     
104.         int key_off, key_lmt;
     
105.         int value_off, value_lmt;
     
106.         int retval;
     
107. 
     
108.         table = NULL;
     
109.         off = 0;
     
110.         skip_charset(text, off, text_len, &off, " \t\r\n", 4);
     
111.         if (skip_text(text, off, text_len, &off, "{", 1) == 0) {
     
112.                 while (off < text_len) {
     
113.                         skip_charset(text, off, text_len, &off, " \t\r\n", 4);
     
114.                         if (skip_text(text, off, text_len, &off, "}", 1) == 0) {
     
115.                                 skip_charset(text, off, text_len, &off, " \t\r\n", 4);
     
116.                                 if (off == text_len) {
     
117.                                         return table;
     
118.                                 }
     
119.                                 break;
     
120.                         }
     
121.                         key_off = off;
     
122.                         retval = skip_until_charset(text, off, text_len, &off, " \t\r\n=", 5);
     
123.                         if (retval == 4) {
     
124.                                 key_lmt = off;
     
125.                                 ++off;
     
126.                         }else if (retval >= 0) {
     
127.                                 key_lmt = off;
     
128.                                 skip_charset(text, off, text_len, &off, " \t\r\n", 4);
     
129.                                 retval = skip_text(text, off, text_len, &off, "=", 1);
     
130.                         }
     
131.                         if (retval != -1) {
     
132.                                 skip_charset(text, off, text_len, &off, " \t\r\n", 4);
     
133.                                 value_off = off;
     
134.                                 retval = skip_until_charset(text, off, text_len, &off, " \t\r\n,}", 6);
     
135.                                 if (retval >= 4) {
     
136.                                         value_lmt = off;
     
137.                                         if (retval == 4) {
     
138.                                                 ++off;
     
139.                                         }
     
140.                                 }else if (retval >= 0) {
     
141.                                         value_lmt = off;
     
142.                                         skip_charset(text, off, text_len, &off, " \t\r\n", 4);
     
143.                                         retval = skip_until_charset(text, off, text_len, &off, ",}", 2);
     
144.                                         if (retval >= 0) {
     
145.                                                 if (retval == 0) {
     
146.                                                         ++off;
     
147.                                                 }
     
148.                                         }
     
149.                                 }
     
150.                         }
     
151.                         if (retval == -1) {
     
152.                                 break;
     
153.                         }else {
     
154.                                 node = (struct key_value_node *)malloc(sizeof(struct key_value_node));
     
155.                                 if (node == NULL) {
     
156.                                         break;
     
157.                                 }
     
158.                                 memset(node, 0, sizeof(struct key_value_node));
     
159.                                 node->key_offset = key_off;
     
160.                                 node->key_limit = key_lmt;
     
161.                                 node->value_offset = value_off;
     
162.                                 node->value_limit = value_lmt;
     
163.                                 if (table == NULL) {
     
164.                                         node->previous = node;
     
165.                                         node->next = node;
     
166.                                         table = node;
     
167.                                 }else {
     
168.                                         node->previous = table->previous;
     
169.                                         node->next = table;
     
170.                                         table->previous->next = node;
     
171.                                         table->previous = node;
     
172.                                 }
     
173.                         }
     
174.                 }
     
175.                 free_key_value_table(table);
     
176.         }
     
177.         return NULL;
     
178. }
     
179. 
     
180. int print_key_value_table(struct key_value_node *table, const char *text, int text_len)
     
181. {
     
182.         struct key_value_node *node;
     
183. 
     
184.         printf("{\n");
     
185.         if (table != NULL) {
     
186.                 node = table;
     
187.                 do {
     
188.                         printf("\t%.*s = %.*s\n", node->key_limit - node->key_offset, text + node->key_offset
     
189.                                 , node->value_limit - node->value_offset, text + node->value_offset);
     
190.                         node = node->next;
     
191.                 }while (node != table);
     
192.         }
     
193.         printf("}\n");
     
194.         return 0;
     
195. }
     
196. 
     
197. int main(void)
     
198. {
     
199.         const char *text = "{C_USER_NETWORK_TYPE=0,C_SUB_SALT=89EE043854C7ACCE,C_SMSAlertsFlag=1,C_IS_GROUP_MEMBER=0,C_MBB_NOTIFY_FLAG=2}";
     
200.         struct key_value_node *table;
     
201.         int text_len;
     
202. 
     
203.         text_len = strlen(text);
     
204.         table = get_key_value_table(text, text_len);
     
205.         if (table != NULL) {
     
206.                 print_key_value_table(table, text, text_len);
     
207.                 free_key_value_table(table);
     
208.         }
     
209.         return 0;
     
210. }
     

复制代码