【C】C语言版的vb字符串函数库

cyycoish

最近用C自己写词法分析器
词法分析器的标准写法是构建自动机进行正则匹配
然而我不走寻常路，自己使用字符串函数拆解字符串
因为我的第一次已经给了vb（请大家不要：{:soso_e127:} ）
所以vb的字符串函数已经扔不掉了，这次用C重写了vb大多数字符串函数。

文件名叫做：cvbstrfun.h，大家只需包含该头文件即可

1. 
   
2. /////////////////////////////////////////////////
   
3. //                Description:                 //
   
4. //            C Style VB Str Func              //
   
5. //              Name:cvbstrfun.h               //
   
6. //               Auther:Cyycoish               //
   
7. //              ID:201506282102A               //
   
8. //          (C) 2015 [url]www.0xaa55.com[/url]            //
   
9. //            All Rights Reserved.             //
   
10. /////////////////////////////////////////////////
    
11. #include <locale.h>
    
12. #include <wchar.h>
    
13. #include <tchar.h>
    
14. #include <malloc.h>
    
15. #define WCHR wchar_t
    
16. //________________________
    
17. //|   <Function Table>   |
    
18. //|______________________|
    
19. //|C Style    |VB Style  |
    
20. //|-----------|----------|
    
21. //|wslen      |Len       |
    
22. //|wsucase    |UCase     |
    
23. //|wsleft     |Left      |
    
24. //|wsinverse  |StrReverse|
    
25. //|wsright    |Right     |
    
26. //|wsmid      |Mid       |
    
27. //|wsinstr    |InStr     |
    
28. //|wsltrim    |LTrim     |
    
29. //|wsrtrim    |RTrim     |
    
30. //|wsinstrrev |InStrRev  |
    
31. //|___________|__________|
    
32. int wslen(WCHR* s)
    
33. {
    
34.         return wcslen(s);
    
35. }
    
36. void wsucase(WCHR* s)
    
37. {
    
38.         int i;
    
39.         for (i = 0; i <= wcslen(s) - 1; i++)
    
40.                 s[i] = towupper(s[i]);
    
41.         return;
    
42. }
    
43. void wslcase(WCHR* s)
    
44. {
    
45.         int i;
    
46.         for (i = 0; i <= wcslen(s) - 1; i++)
    
47.                 s[i] = towlower(s[i]);
    
48.         return;
    
49. }
    
50. WCHR* wsleft(WCHR* szTar, int n)
    
51. {
    
52.         int i;
    
53.         WCHR* rtn;
    
54.         WCHR tmpWChr[2] = {'\0', '\0'};
    
55.         if (n > wcslen(szTar))
    
56.                 return L"";
    
57.         rtn = (WCHR*)malloc(sizeof(szTar));
    
58.         wcscpy(rtn, L"");
    
59.         for (i = 0; i <= n - 1; i++)
    
60.         {
    
61.                 tmpWChr[0] = szTar[i];
    
62.                 wcscat(rtn, tmpWChr);
    
63.         }
    
64.         return rtn;
    
65. }
    
66. void wsinverse(WCHR* szTar)
    
67. {
    
68.         int i, j, l;
    
69.         WCHR* rtn;
    
70.         WCHR tmpWChr[2] = {'\0', '\0'};
    
71.         l = wcslen(szTar);
    
72.         rtn = (WCHR*)malloc(sizeof(szTar));
    
73.         wcscpy(rtn, L"");
    
74.         for (i = 0, j = l - 1; i < wcslen(szTar); i++, j--)
    
75.         {
    
76.                 rtn[j] = szTar[i];
    
77.         }
    
78.         rtn[i] = '\0';
    
79.         wcscpy(szTar, rtn);
    
80. }
    
81. WCHR* wsright(WCHR* szTar, int n)
    
82. {
    
83.         int i, j, l;
    
84.         WCHR* rtn;
    
85.         WCHR tmpWChr[2] = {'\0', '\0'};
    
86.         l = wcslen(szTar);
    
87.         if (n > l)
    
88.                 return L"";
    
89.         rtn = (WCHR*)malloc(sizeof(szTar));
    
90.         wcscpy(rtn, L"");
    
91.         for (i = l - 1, j = 1; j <= n; i--, j++)
    
92.         {
    
93.                 tmpWChr[0] = szTar[i];
    
94.                 wcscat(rtn, tmpWChr);
    
95.         }
    
96.         wsinverse(rtn);
    
97.         return rtn;
    
98. }
    
99. WCHR* wsmid(WCHR* szTar, int st, int n)
    
100. {
     
101.         int i;
     
102.         WCHR* rtn;
     
103.         WCHR tmpWChr[2] = {'\0', '\0'};
     
104.         if ((st - 1 + n) > wcslen(szTar))
     
105.                 return L"";
     
106.         rtn = (WCHR*)malloc(sizeof(szTar));
     
107.         wcscpy(rtn, L"");
     
108. 
     
109.         for (i = st - 1; i <= st + n - 2; i++)
     
110.         {
     
111.                 tmpWChr[0] = szTar[i];
     
112.                 wcscat(rtn, tmpWChr);
     
113.         }
     
114.         return rtn;
     
115. }
     
116. int wsinstr(WCHR* szTar, WCHR* szCmp, int st)
     
117. {
     
118.         int i;
     
119.         if (st >= wcslen(szTar) - wcslen(szCmp))
     
120.                 return -1;
     
121.         for (i = st; i <= wcslen(szTar); i++)
     
122.         {
     
123.                 if (!wcscmp(szCmp, wsmid(szTar, i, wcslen(szCmp))))
     
124.                         return i;
     
125.         }
     
126.         return -1;
     
127. }
     
128. void wsltrim(WCHR* szTar)
     
129. {
     
130.         int i;
     
131.         int b = 0;
     
132.         WCHR* rtn;
     
133.         WCHR tmpWChr[2] = {'\0', '\0'};
     
134.         rtn = (WCHR*)malloc(sizeof(szTar));
     
135.         wcscpy(rtn, L"");
     
136.         for (i = 0; i < wcslen(szTar); i++)
     
137.         {
     
138.                 tmpWChr[0] = szTar[i];
     
139.                 if (tmpWChr[0] != ' ' || b != 0)
     
140.                 {
     
141.                         wcscat(rtn, tmpWChr);
     
142.                         if (tmpWChr[0] != ' ' && b == 0)
     
143.                                 b = !(b);
     
144.                 }
     
145.         }
     
146.         wcscpy(szTar, rtn);
     
147. }
     
148. void wsrtrim(WCHR* szTar)
     
149. {
     
150.         int i, j, l;
     
151.         int b = 0;
     
152.         WCHR* rtn;
     
153.         WCHR tmpWChr[2] = {'\0', '\0'};
     
154.         l = wcslen(szTar);
     
155.         rtn = (WCHR*)malloc(sizeof(szTar));
     
156.         wcscpy(rtn, L"");
     
157.         for (i = l - 1, j = 1; j < l; i--, j++)
     
158.         {
     
159.                 tmpWChr[0] = szTar[i];
     
160.                 if (tmpWChr[0] != ' ' || b != 0)
     
161.                 {
     
162.                         wcscat(rtn, tmpWChr);
     
163.                         if (tmpWChr[0] != ' ' && b == 0)
     
164.                                 b = !(b);
     
165.                 }
     
166.         }
     
167.         wsinverse(rtn);
     
168.         wcscpy(szTar, rtn);
     
169. }
     
170. int wsinstrrev(WCHR* szTar, WCHR* szCmp, int st)
     
171. {
     
172.         int i;
     
173.         WCHR* s1, * s2;
     
174.         s1 = (WCHR*)malloc(sizeof(szTar));
     
175.         s2 = (WCHR*)malloc(sizeof(szCmp));
     
176.         wcscpy(s1, szTar); wcscpy(s2, szCmp);
     
177.         wsinverse(s1); wsinverse(s2);
     
178.         if (st >= wcslen(szTar) - wcslen(szCmp))
     
179.                 return -1;
     
180.         for (i = st; i < wcslen(szTar); i++)
     
181.         {
     
182.                 if (!wcscmp(s2, wsmid(s1, i, wcslen(s2))))
     
183.                 {
     
184.                         return wcslen(szTar) - i + 1;
     
185.                 }
     
186.         }
     
187.         return -1;
     
188. }
     

复制代码

还有一点 大家需要注意的是：
因为是宽字符，所以main函数调用该头文件，使用函数时要locate一下，具体做法如下：

1. #include <stdio.h>
   
2. #include "cvbstrfun.h"
   
3. 
   
4. int _tmain(int argc, wchar_t* argv[])
   
5. {
   
6.        
   
7.         WCHR str[] = {L"abcdefg"};
   
8.         //int a;
   
9.         setlocale(LC_CTYPE, ""); //就是这个关键的一句，不加显示不了中文
   
10.         //wcscpy(str, wsleft(str, 2));
    
11.         //wsinverse(str);
    
12.         //wcscpy(str, wsright(str, 3));
    
13.         //wcscpy(str, wsmid(str, 3, 2));
    
14.         //wsucase(str);
    
15.         //wsrtrim(str);
    
16.         //a = wsinstrrev(L"aabccccc", L"b", 1);
    
17.         //wprintf(L""%s"\n", str);
    
18.         //printf("\n%d\n", a);
    
19.        
    
20.         return 0;
    
21. }

复制代码

0xAA55

哪天你再实现一下strstr strcpy strchr strcmp sprintf等函数的VB版本吧。
嘛。我开玩笑的。不必为此浪费时间哦。

0x01810

wsinverse 函数里的 rtn 是忘记释放的节奏?

cyycoish

0x01810 发表于 2015-7-7 16:22
wsinverse 函数里的 rtn 是忘记释放的节奏?

这个rtn不可以释放啊
wcscpy是直接传地址的
rtn free掉了以后，szTar就木有了

cyycoish

重写了一下wsinstrrev：

1. int wsinstrrev(const WCHR* szTar, const WCHR* szCmp, int st)
   
2. {
   
3.         int i;
   
4.         for (i = wcslen(szTar) - wcslen(szCmp) + 1; i >= st; i--)
   
5.                 if (!wcscmp(szCmp, wsmid(szTar, i, wcslen(szCmp))))
   
6.                         return i;
   
7.         return -1;
   
8. }

复制代码

0x01810

cyycoish 发表于 2015-7-7 22:34
这个rtn不可以释放啊
wcscpy是直接传地址的
rtn free掉了以后，szTar就木有了 ...

不是应该这样写吗:

1. 
   
2. void wsinverse(WCHAR* szTar)
   
3. {
   
4.         int i, j, l;
   
5.         WCHAR* rtn;
   
6.         l = wcslen(szTar);
   
7.         rtn = (WCHAR*)malloc(sizeof(szTar));
   
8.         wcscpy(rtn, L"");
   
9.         for (i = 0, j = l - 1; i < wcslen(szTar); i++, j--)
   
10.         {
    
11.                 rtn[j] = szTar[i];
    
12.         }
    
13.         rtn[i] = '\0';
    
14.         wcscpy(szTar, rtn);
    
15.         free(rtn);
    
16. }
    

复制代码

cyycoish

0x01810 发表于 2015-7-8 14:41
不是应该这样写吗:
[code]
void wsinverse(WCHAR* szTar)

wsinverse是这样声明的：void wsinverse(WCHAR* szTar) 如果调用wsinverse，函数修改的是原本传入的那个字符串。然后，在函数内部，有这么一句：wcscpy(szTar, rtn);。咱们来看一下wcscpy的声明：wchar_t * __cdecl wcscpy(wchar_t * _Dest, const wchar_t * _Source)。这样一来rtn所指向的地址就完完全全给了szTar，换句话说，刚刚传入的那个字符串的内存地址变成了malloc出来的rtn所指向的地址。如果这时候free，相当于free了传入字符串的地址。打个简单的比方吧：我借了你的作业，作业本到手以后，因为某种原因，我不小心把你的字全擦了。后来呢，我又叫A5帮你重写了一遍。这时候，若要擦掉A5写的的作业，就等于擦掉了你的本子上所有的内容，你也就拿着一个空本子了。@0xAA55 <=A5惨遭背锅

cyycoish

呐，最新版本：

1. #include <locale.h>
   
2. #include <wchar.h>
   
3. #include <tchar.h>
   
4. #include <malloc.h>
   
5. #define WCHR wchar_t
   
6. //String Functions
   
7. int wslen(const WCHR* s)
   
8. {
   
9.         return wcslen(s);
   
10. }
    
11. void wsucase(WCHR* s)
    
12. {
    
13.         int i;
    
14.         for (i = 0; i <= wcslen(s) - 1; i++)
    
15.                 s[i] = towupper(s[i]);
    
16.         return;
    
17. }
    
18. void wslcase(WCHR* s)
    
19. {
    
20.         int i;
    
21.         for (i = 0; i <= wcslen(s) - 1; i++)
    
22.                 s[i] = towlower(s[i]);
    
23.         return;
    
24. }
    
25. WCHR* wsleft(const WCHR* szTar, int n)
    
26. {
    
27.         int i;
    
28.         WCHR* rtn;
    
29.         WCHR tmpWChr[2] = {'\0', '\0'};
    
30.         if (n > wcslen(szTar))
    
31.                 return L"";
    
32.         rtn = (WCHR*)malloc(sizeof(szTar));
    
33.         wcscpy(rtn, L"");
    
34.         for (i = 0; i <= n - 1; i++)
    
35.         {
    
36.                 tmpWChr[0] = szTar[i];
    
37.                 wcscat(rtn, tmpWChr);
    
38.         }
    
39.         return rtn;
    
40. }
    
41. void wsinverse(WCHR* szTar)
    
42. {
    
43.         int i, j, k;
    
44.         WCHR* rtn;
    
45.         WCHR tmpWChr[2] = {'\0', '\0'};
    
46.         k = wcslen(szTar);
    
47.         rtn = (WCHR*)malloc(sizeof(szTar));
    
48.         wcscpy(rtn, L"");
    
49.         for (i = 0, j = k - 1; i < wcslen(szTar); i++, j--)
    
50.         {
    
51.                 rtn[j] = szTar[i];
    
52.         }
    
53.         rtn[i] = '\0';
    
54.         wcscpy(szTar, rtn);
    
55. }
    
56. WCHR* wsright(const WCHR* szTar, int n)
    
57. {
    
58.         int i, j, l;
    
59.         WCHR* rtn;
    
60.         WCHR tmpWChr[2] = {'\0', '\0'};
    
61.         l = wcslen(szTar);
    
62.         if (n > l)
    
63.                 return L"";
    
64.         rtn = (WCHR*)malloc(sizeof(szTar));
    
65.         wcscpy(rtn, L"");
    
66.         for (i = l - 1, j = 1; j <= n; i--, j++)
    
67.         {
    
68.                 tmpWChr[0] = szTar[i];
    
69.                 wcscat(rtn, tmpWChr);
    
70.         }
    
71.         wsinverse(rtn);
    
72.         return rtn;
    
73. }
    
74. WCHR* wsmid(const WCHR* szTar, int st, int n)
    
75. {
    
76.         int i;
    
77.         WCHR* rtn;
    
78.         WCHR tmpWChr[2] = {'\0', '\0'};
    
79.         if ((st - 1 + n) > wcslen(szTar))
    
80.                 return L"";
    
81.         rtn = (WCHR*)malloc(sizeof(szTar));
    
82.         wcscpy(rtn, L"");
    
83. 
    
84.         for (i = st - 1; i <= st + n - 2; i++)
    
85.         {
    
86.                 tmpWChr[0] = szTar[i];
    
87.                 wcscat(rtn, tmpWChr);
    
88.         }
    
89.         return rtn;
    
90. }
    
91. int wsinstr(const WCHR* szTar, const WCHR* szCmp, int st)
    
92. {
    
93.         int i;
    
94.         if (st >= wcslen(szTar) - wcslen(szCmp))
    
95.                 return -1;
    
96.         for (i = st; i <= wcslen(szTar); i++)
    
97.         {
    
98.                 if (!wcscmp(szCmp, wsmid(szTar, i, wcslen(szCmp))))
    
99.                         return i;
    
100.         }
     
101.         return -1;
     
102. }
     
103. void wsltrim(WCHR* szTar)
     
104. {
     
105.         int i;
     
106.         int b = 0;
     
107.         WCHR* rtn;
     
108.         WCHR tmpWChr[2] = {'\0', '\0'};
     
109.         rtn = (WCHR*)malloc(sizeof(szTar));
     
110.         wcscpy(rtn, L"");
     
111.         for (i = 0; i < wcslen(szTar); i++)
     
112.         {
     
113.                 tmpWChr[0] = szTar[i];
     
114.                 if (tmpWChr[0] != ' ' || b != 0)
     
115.                 {
     
116.                         wcscat(rtn, tmpWChr);
     
117.                         if (tmpWChr[0] != ' ' && b == 0)
     
118.                                 b = !(b);
     
119.                 }
     
120.         }
     
121.         wcscpy(szTar, rtn);
     
122. }
     
123. void wsrtrim(WCHR* szTar)
     
124. {
     
125.         int i, j, l;
     
126.         int b = 0;
     
127.         WCHR* rtn;
     
128.         WCHR tmpWChr[2] = {'\0', '\0'};
     
129.         l = wcslen(szTar);
     
130.         rtn = (WCHR*)malloc(sizeof(szTar));
     
131.         wcscpy(rtn, L"");
     
132.         for (i = l - 1, j = 1; j < l; i--, j++)
     
133.         {
     
134.                 tmpWChr[0] = szTar[i];
     
135.                 if (tmpWChr[0] != ' ' || b != 0)
     
136.                 {
     
137.                         wcscat(rtn, tmpWChr);
     
138.                         if (tmpWChr[0] != ' ' && b == 0)
     
139.                                 b = !(b);
     
140.                 }
     
141.         }
     
142.         wsinverse(rtn);
     
143.         wcscpy(szTar, rtn);
     
144. }
     
145. int wsinstrrev(const WCHR* szTar, const WCHR* szCmp, int st)
     
146. {
     
147.         int i;
     
148.         for (i = wcslen(szTar) - wcslen(szCmp) + 1; i >= st; i--)
     
149.                 if (!wcscmp(szCmp, wsmid(szTar, i, wcslen(szCmp))))
     
150.                         return i;
     
151.         return -1;
     
152. }
     
153. //End String Functions
     

复制代码

0xAA55

cyycoish 发表于 2015-7-8 17:27
呐，最新版本：
[code]#include
#include

@0x01810 说得对。那个地址确实要释放。你只是分配了一块内存用于临时存储翻转后的字符串而已。用完后，你需要释放这块内存。

cyycoish

0xAA55 发表于 2015-7-8 18:54
@0x01810 说得对。那个地址确实要释放。你只是分配了一块内存用于临时存储翻转后的字符串而已。用完后， ...

但是。。。释放后就。。。。

0xAA55

cyycoish 发表于 2015-7-8 20:20
但是。。。释放后就。。。。

rtn = (WCHR*)malloc(sizeof(szTar));
其中szTar是个指针，也就是说，sizeof(szTar)的值，x86的时候是4，x64的时候是8，然后它的前后有malloc的一些数据，被你来个缓冲区溢出，破坏了。自然，free也不能成功。
这不是VB，这是C，你需要把sizeof(szTar)改成字符串的实际长度。

cyycoish

终于，在站长的指导下完成了50%，这里要特别感谢A5站长@0xAA55
算是一次阶段性的成功：

1. /////////////////////////////////////////////////
   
2. //                Description:                 //
   
3. //              String Functions               //
   
4. //                Name:StrFun.h                //
   
5. //              Auther:Cosh Cage               //
   
6. //              ID:201507082140C               //
   
7. /////////////////////////////////////////////////
   
8. #include <locale.h>
   
9. #include <wchar.h>
   
10. #include <tchar.h>
    
11. #include <malloc.h>
    
12. 
    
13. #define WCHR wchar_t
    
14. /*
    
15. int   wslen     (const WCHR* s);
    
16. void  wsucase   (WCHR* s);
    
17. void  wslcase   (WCHR* s);
    
18. WCHR* wsleft    (const WCHR* szTar, int n);
    
19. void  wsinverse (WCHR* szTar);
    
20. WCHR* wsright   (const WCHR* szTar, int n);
    
21. WCHR* wsmid     (const WCHR* szTar, int st, int n);
    
22. int   wsinstr   (const WCHR* szTar, const WCHR* szCmp, int st);
    
23. void  wsltrim   (WCHR* szTar);
    
24. void  wsrtrim   (WCHR* szTar);
    
25. int   wsinstrrev(const WCHR* szTar, const WCHR* szCmp, int st);
    
26. */
    
27. //String Functions
    
28. int wslen(const WCHR* s)
    
29. {
    
30.         return wcslen(s);
    
31. }
    
32. void wsucase(WCHR* s)
    
33. {
    
34.         int i;
    
35.         for (i = 0; i <= wcslen(s) - 1; i++)
    
36.                 s[i] = towupper(s[i]);
    
37.         return;
    
38. }
    
39. void wslcase(WCHR* s)
    
40. {
    
41.         int i;
    
42.         for (i = 0; i <= wcslen(s) - 1; i++)
    
43.                 s[i] = towlower(s[i]);
    
44.         return;
    
45. }
    
46. WCHR* wsleft(const WCHR* szTar, int n)
    
47. {
    
48.         int i;
    
49.         WCHR* rtn;
    
50.         WCHR tmpWChr[2] = {'\0', '\0'};
    
51.         if (n > wcslen(szTar))
    
52.                 return L"";
    
53.         rtn = (WCHR*)malloc(sizeof(WCHR) * (wcslen(szTar) + 1));
    
54.         wcscpy(rtn, L"");
    
55.         for (i = 0; i <= n - 1; i++)
    
56.         {
    
57.                 tmpWChr[0] = szTar[i];
    
58.                 wcscat(rtn, tmpWChr);
    
59.         }
    
60.         return rtn;
    
61. }
    
62. void wsinverse(WCHR* szTar)
    
63. {
    
64.         int i, j, k;
    
65.         WCHR* rtn;
    
66.         k = wcslen(szTar);
    
67.         rtn = (WCHR*)malloc(sizeof(WCHR) * (k + 1));
    
68.         for (i = 0, j = k - 1; i < wcslen(szTar); i++, j--)
    
69.         {
    
70.                 rtn[j] = szTar[i];
    
71.         }
    
72.         rtn[i] = '\0';
    
73.         wcscpy(szTar, rtn);
    
74.         free(rtn);
    
75. }
    
76. WCHR* wsright(const WCHR* szTar, int n)
    
77. {
    
78.         int i, j, k;
    
79.         WCHR* rtn;
    
80.         WCHR tmpWChr[2] = {'\0', '\0'};
    
81.         k = wcslen(szTar);
    
82.         if (n > k)
    
83.                 return L"";
    
84.         rtn = (WCHR*)malloc(sizeof(WCHR) * (k + 1));
    
85.         wcscpy(rtn, L"");
    
86.         for (i = k - 1, j = 1; j <= n; i--, j++)
    
87.         {
    
88.                 tmpWChr[0] = szTar[i];
    
89.                 wcscat(rtn, tmpWChr);
    
90.         }
    
91.         wsinverse(rtn);
    
92.         return rtn;
    
93. }
    
94. WCHR* wsmid(const WCHR* szTar, int st, int n)
    
95. {
    
96.         int i;
    
97.         WCHR* rtn;
    
98.         WCHR tmpWChr[2] = {'\0', '\0'};
    
99.         if ((st - 1 + n) > wcslen(szTar))
    
100.                 return L"";
     
101.         rtn = (WCHR*)malloc(sizeof(WCHR) * (wcslen(szTar) + 1));
     
102.         wcscpy(rtn, L"");
     
103. 
     
104.         for (i = st - 1; i <= st + n - 2; i++)
     
105.         {
     
106.                 tmpWChr[0] = szTar[i];
     
107.                 wcscat(rtn, tmpWChr);
     
108.         }
     
109.         return rtn;
     
110. }
     
111. int wsinstr(const WCHR* szTar, const WCHR* szCmp, int st)
     
112. {
     
113.         int i;
     
114.         if (st >= wcslen(szTar) - wcslen(szCmp))
     
115.                 return -1;
     
116.         for (i = st; i <= wcslen(szTar); i++)
     
117.         {
     
118.                 if (!wcscmp(szCmp, wsmid(szTar, i, wcslen(szCmp))))
     
119.                         return i;
     
120.         }
     
121.         return -1;
     
122. }
     
123. void wsltrim(WCHR* szTar)
     
124. {
     
125.         int i;
     
126.         int b = 0;
     
127.         WCHR* rtn;
     
128.         WCHR tmpWChr[2] = {'\0', '\0'};
     
129.         rtn = (WCHR*)malloc(sizeof(WCHR) * (wcslen(szTar) + 1));
     
130.         wcscpy(rtn, L"");
     
131.         for (i = 0; i < wcslen(szTar); i++)
     
132.         {
     
133.                 tmpWChr[0] = szTar[i];
     
134.                 if (tmpWChr[0] != ' ' || b != 0)
     
135.                 {
     
136.                         wcscat(rtn, tmpWChr);
     
137.                         if (tmpWChr[0] != ' ' && b == 0)
     
138.                                 b = !(b);
     
139.                 }
     
140.         }
     
141.         wcscpy(szTar, rtn);
     
142.         free(rtn);
     
143. }
     
144. void wsrtrim(WCHR* szTar)
     
145. {
     
146.         int i, j, k;
     
147.         int b = 0;
     
148.         WCHR* rtn;
     
149.         WCHR tmpWChr[2] = {'\0', '\0'};
     
150.         k = wcslen(szTar);
     
151.         rtn = (WCHR*)malloc(sizeof(WCHR) * (k + 1));
     
152.         wcscpy(rtn, L"");
     
153.         for (i = k - 1, j = 0; j < k; i--, j++)
     
154.         {
     
155.                 tmpWChr[0] = szTar[i];
     
156.                 if (tmpWChr[0] != ' ' || b != 0)
     
157.                 {
     
158.                         wcscat(rtn, tmpWChr);
     
159.                         if (tmpWChr[0] != ' ' && b == 0)
     
160.                                 b = !(b);
     
161.                 }
     
162.         }
     
163.         wsinverse(rtn);
     
164.         wcscpy(szTar, rtn);
     
165.         free(rtn);
     
166. }
     
167. int wsinstrrev(const WCHR* szTar, const WCHR* szCmp, int st)
     
168. {
     
169.         int i;
     
170.         for (i = wcslen(szTar) - wcslen(szCmp) + 1; i >= st; i--)
     
171.                 if (!wcscmp(szCmp, wsmid(szTar, i, wcslen(szCmp))))
     
172.                         return i;
     
173.         return -1;
     
174. }
     
175. //End String Functions
     

复制代码