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

cyycoish

vb的字符串函数很好用，而c的却不怎么友好，于是写了C语言版的vb字符串函数库，大家包含头文件即可：

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

复制代码