字符串操作

输入一个英文句子，翻转句子中单词的顺序，单词内字符顺序不变

题目：输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。句子中单词以空格符隔开。为简单起见，标点符号和普通字母一样处理。例如输入“I am a student.”，则输出“student. a am I”。

处理方法是首先将整个句子翻转，然后再将其中的每个单词翻转。

代码如下：

 

[cpp]  view plain  copy

 print ?

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. void myReverse(char*, char*);  
6. char * senReverse(char*);  
7. int main()  
8. {  
9.     char sen[]="hello, I am a student!";  
10.     char *result=senReverse(sen);  
11.     cout << result << endl;  
12.     return 0;  
13. }  
14. void myReverse(char *start, char *end)  
15. {  
16.     char temp;  
17.     while(start<end)  
18.     {  
19.         temp=*start;  
20.         *start=*end;  
21.         *end=temp;  
22.         start++;  
23.         end--;  
24.     }  
25. }  
26. char * senReverse(char *sen)  
27. {  
28.     char *start=sen, *end=sen+strlen(sen)-1;  
29.     myReverse(start, end);  //先反转整个句子  
30.   
31.    /*此注释部分是另外一种实现，只不过看起来有些繁琐 
32.     int loc;  //记录每个单词的长度 
33.     for(start=sen,end=start;(*end)!='\0';start+=loc) 
34.     { 
35.         loc=0; 
36.         while((*end)!=' '&&(*end)!='\0'){end++, loc++;} 
37.         end--; 
38.         myReverse(start, end); 
39.         end+=2; 
40.         loc++; 
41.     } 
42.     */  
43.     end=start;  
44.     while(*start!='\0')  
45.     {  
46.         if(*end==' '||*end=='\0')  
47.         {  
48.             myReverse(start, --end);  
49.             if(*end=='\0')  
50.                 break;  
51.             end+=2;  
52.             start=end;  
53.         }  
54.         else  
55.             ++end;  
56.     }  
57.   
58.     return sen;  
59. }  

C实现中英文字符串反转

================================================================================

===================================================================================

#include <stdio.h>

#include<string.h>

char *str= "汉字里有english也能正确显hehe" ;

 

int main() {

   int i = strlen (str) - 1;

   while (i>=0) {

     str[i] < 0? printf ( "%c%c%c\n" , str[i-2], str[i-1],str[i]): printf ( "%c\n" , str[i]);

     i--;

   }

   return 0;

}

====================================================================

=====================================================================

#include <stdio.h>

#include<string.h>

char *str= "汉字里有english也能正确显hehe" ;

 

int main() {

   int i = strlen (str) - 1;

   while (i>=0) {

   

         if (str[i] < 0)

         {

                 printf ( "%c%c%c\n" , str[i-2], str[i-1],str[i]);

                 i = i-2;

         } else {

                 printf ( "%c\n" , str[i]);

         }

         i--;

   }

   return 0;

}

汉字占两个字节，数字和英文字母占一个字节，要输出的话首先判断是英文数字还是汉字，

ANSI:汉字区的内码范围高字节从B0-F7,低字节从A1-FE

Unicode:汉字的Unicode编码范围为\u4E00-\u9FA5 \uF900-\uFA2D

 

可知我们只要判断高位字节的最高位是否为一就可以

 

[html]  view plain  copy

1. string  s = "一二257【漂亮【jkljl";  
2. for(int i=0;i<s.length();i++){  
3.     if( s.at(i) & 0x80 ){//s.at(i) < 0  
4.         //中文  
5.         string word;  
6.         word+=s.at(i);  
7.         word+=s.at(i+1);  
8.         cout<< word<<endl;  
9.         i++;  
10.           
11.     }else{  
12.         cout<< s.at(i)<<endl;  
13.     }  
14. }  

c++截取汉字和英文混合字符串

在C++里截取字符串可以使用string.substr()，可是这个函数只能按英文来截取，

如果是汉字可能就要计算好字符个数，如果是汉字和英文混合，那就只能望洋兴叹了。

可是恰好我需要这样一个函数，于是就自己实现了一个，其中如何判断汉字和英文

参看了此处。

代码简单也无优化，若有更好的方法欢迎提出，代码如下。

#include <iostream>
#include <string>
#include<cstdio>
#include<vector>
#include<typeinfo>
using namespace std;

int is_zh_ch(char p)
{

    /*汉字的两个字节的最高为都为1,这里采用判断最高位的方法
    将p字节进行移位运算，右移8位，这样，如果移位后是0，
    则说明原来的字节最高位为0，不是1那么也就不是汉字的一个字节
    */
    if(~(p >> 8) == 0)
    {
        return 1;//代表不是汉字
    }

    return -1;
}



string sub(string str,int start,int end=-1)
{

    if(typeid(str)==typeid(string) && str.length()>0)
    {
        int len=str.length();

        string tmp="";

        //先把str里的汉字和英文分开
        vector <string> dump;
        int i=0;
        while(i<len)
        {
            if (is_zh_ch(str.at(i))==1)
            {
                dump.push_back(str.substr(i,2));
                i=i+2;

            }
            else
            {
                dump.push_back(str.substr(i,1));
                i=i+1;
            }
        }


        end=end>0?end:dump.size(); //end默认为dump.size
        if(start<0||start>end)
            printf("start is wrong");
　　　　　//直接从dump里取即可
        for(i=start; i<=end; i++)
        {
            tmp+=dump[i-1];
        }

        return tmp;
    }
    else
    {
        printf("str is not string\n");
        return "";

    }
}

int main()
{
    string p="半山wuji";
    cout<<sub(p,1,1)<<endl;
    cout<<sub(p,2,2)<<endl;
    cout<<sub(p,3);
}

输出如下：

半
山
wuji

符合我的要求。

#include "stdafx.h"
#include <stdio.h>
#include<string.h>
char *str="汉字里有english也能正确显hehe";


int _tmain(int argc, _TCHAR* argv[])
{
char s[256],ss[256]; int i,k;
scanf("%s",s); k=strlen(s);
for ( i=0;i<k;i+=2 ) { ss[k-i-2]=s[i]; ss[k-i-1]=s[i+1]; } //循环变量+=2，每次处理1个汉字、2个字符
ss[k]=0; //字符串结尾需要赋值
printf("%s\n",ss);
}

 

C++实现中英文与UNICODE十六进制字符串互转

标签： c++hexstringnulldeleteinput

2012-02-29 15:06  10071人阅读  评论(2)  收藏  举报

  分类：

wince（26）   QT/C++（9）   C/C++（12） 

版权声明：本文为博主原创文章，未经博主允许不得转载。

之前搞过这个中英文与UNICODE十六进制字符串的互转，但是发现有点小问题。现在重新搞了一个，测试中暂时没有发现什么问题。先记录下来。

我尝试使用过MultiByteToWideChar和WideCharToMultiByte来实现这个功能，但是发现不行。也就是无法实现如：

中文English  --> 4e2d65870045006e0067006c006900730068

和

4e2d65870045006e0067006c006900730068 --> 中文English

这么一个转换，上述的都是字符串。

好看下面的源码：YCodec是自己写的一个类

YCodec.h文件源码：

[cpp]  view plain  copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. class YCodec  
5. {  
6. public:  
7.     YCodec();  
8.     ~YCodec();  
9.     // char to hex code  
10.     int Char2Hex(char ch);  
11.     // hex to char  
12.     char Hex2Char(unsigned int n);  
13.     // num^<span style="background-color: rgb(255, 255, 255); ">index</span>  
14.     long MIndex(int num, int index);  
15.     // string to hex code  
16.     long String2Hex(char* string, int strlen);  
17.     // hex to char*  
18.     int Hex2String(long hex, char* string, int* slen);  
19.     // hex to wchar_t code  
20.     wchar_t Hex2Wchart(long hex);  
21.     // UNICODE十六进制字符串转成中英文  
22.     // hex string to wchar_t*  
23.     int HexStr2WChars(char* hexstr, int hexstrlen, int eachchar, wchar_t* wchs, int* wchslen);  
24.     // wchar_t to hex code  
25.     long Wchart2Hex(wchar_t wch);  
26.     // 中英文转成UNICODE十六进制字符串  
27.     // wchar_t* to char*(hex string)  
28.     int Wchart2HexStr(wchar_t* wchs, int wchslen, int eachchar, char* hexstr, int* hexstrlen);  
29.   
30. };  

YCodec.cpp文件源码：

[cpp]  view plain  copy

1. #include "StdAfx.h"  
2. #include "YCodec.h"  
3. #include <stdio.h>  
4. #include <stdlib.h>  
5. #include <string.h>  
6.   
7. YCodec::YCodec()  
8. {  
9. }  
10.   
11. YCodec::~YCodec()  
12. {  
13. }  
14.   
15.   
16. // char to hex code  
17. // error: return -1   
18. int YCodec::Char2Hex(char ch)  
19. {  
20.     int n = -1;  
21.     switch(ch)  
22.     {  
23.     case '0':   n = 0;  break;  
24.     case '1':   n = 1;  break;  
25.     case '2':   n = 2;  break;  
26.     case '3':   n = 3;  break;  
27.     case '4':   n = 4;  break;  
28.     case '5':   n = 5;  break;  
29.     case '6':   n = 6;  break;  
30.     case '7':   n = 7;  break;  
31.     case '8':   n = 8;  break;  
32.     case '9':   n = 9;  break;  
33.     case 'A':  
34.     case 'a':   n = 10; break;  
35.     case 'B':  
36.     case 'b':   n = 11; break;  
37.     case 'C':  
38.     case 'c':   n = 12; break;  
39.     case 'D':  
40.     case 'd':   n = 13; break;  
41.     case 'E':  
42.     case 'e':   n = 14; break;  
43.     case 'F':  
44.     case 'f':   n = 15; break;  
45.     default:    break;  
46.     }  
47.   
48.     return n;  
49. }  
50.   
51. // hex to char  
52. // error: return -1   
53. char YCodec::Hex2Char(unsigned int n)  
54. {  
55.     char ch;  
56.     if(n>=0 && n<=9)  ch = 48 + n;  
57.     else if(n>=10 && n<=15)   ch = 65 - 10 + n;  
58.     else ch = -1;  
59.   
60.     return ch;  
61. }  
62.   
63. // num^<span style="background-color: rgb(255, 255, 255); ">index</span>  
64. long YCodec::MIndex(int num, int index)  
65. {  
66.     long s = 1;  
67.     int i=0;  
68.     while(i<index)  
69.     {  
70.         s *= num;  
71.         i++;  
72.     }  
73.   
74.     return s;  
75. }  
76.   
77. // string to hex code  
78. // error: return -1   
79. long YCodec::String2Hex(char* string, int strlen)  
80. {  
81.     long hex=-1;  
82.     int i=0, n=0;  
83.     char *p = string;  
84.     p += strlen - 1;  
85.     if(string == NULL)  return hex;  
86.     if(strlen <= 0 || strlen > 10)    return hex;  
87.   
88.     hex = 0;  
89.     do  
90.     {  
91.         n = Char2Hex(*p--);  
92.         hex += n*MIndex(16, i++);  
93.     }while(i<strlen);  
94.   
95.     return hex;  
96. }  
97.   
98. // hex to char*  
99. // string==NULL,slen = the size of string(slen as output)  
100. // string!=NULL,input the length of string  
101. // error: return -1  
102. int YCodec::Hex2String(long hex, char* string, int* slen)  
103. {  
104.     char tmp[11] = {0};  
105.     if(hex < 0)  return -1;  
106.     if(string == NULL){// count the length it will be used  
107.         sprintf(tmp, "%x", hex);  
108.         *slen = strlen(tmp);  
109.         return 1;  
110.     }  
111.     memset(string, 0, *slen);  
112.     sprintf(string, "%x", hex);  
113.   
114.     return 1;  
115. }  
116.   
117. // hex to wchar_t code  
118. // eg: input 0x5e74, return 年  
119. // error: return -1  
120. wchar_t YCodec::Hex2Wchart(long hex)  
121. {  
122.     wchar_t wch = -1;  
123.     if(hex <0)   return wch;  
124.     wch = (wchar_t)hex;  
125.   
126.     return wch;  
127. }  
128.   
129. // hex string to wchar_t*  
130. // UNICODE十六进制字符串转成中英文  
131. // hexstr每eachchar转换为一个wchar_t  
132. // wchs == NULL, wchsLen as output(the size of wchs will be used)  
133. // error: return -1  
134. int YCodec::HexStr2WChars(char *hexstr, int hexstrlen, int eachchar, wchar_t *wchs, int *wchsLen)  
135. {  
136.     if(hexstr == NULL || hexstrlen <= 0 || eachchar <= 0) return -1;  
137.     if(wchs == NULL){// count the size wchs it will be used  
138.         *wchsLen = hexstrlen/eachchar + (hexstrlen%eachchar>0 ? 1 : 0);  
139.         return 1;  
140.     }  
141.     memset(wchs, 0, *wchsLen * sizeof(wchar_t));  
142.     char* tmp = new char[eachchar+1];  
143.     char* p = hexstr;  
144.     wchar_t* pwch = wchs;  
145.     for(int i=0; i<hexstrlen; i+=eachchar){  
146.         memset(tmp, 0, eachchar+1);  
147.         // get eachchar char  
148.         for(int j=0; j<eachchar; j++){  
149.             if(i+j > hexstrlen)  break;  
150.             tmp[j] = *p++;  
151.         }  
152.         // char* to hex  
153.         long hex = String2Hex(tmp, strlen(tmp));  
154.         if(hex == -1)   continue;  
155.         // hex to wchar_t  
156.         *pwch++ = Hex2Wchart(hex);  
157.     }  
158.   
159.     if(tmp) delete []tmp;  
160.   
161.     return 1;  
162. }  
163.   
164. // wchar_t to hex code  
165. long YCodec::Wchart2Hex(wchar_t wch)  
166. {  
167.     return (long)wch;  
168. }  
169.   
170. // wchar_t* to char*(hex string)  
171. // 中英文转成UNICODE十六进制字符串  
172. // eachchar用于控制每个wchar_t转换成多少个char字符  
173. // hexstr == NULL,hexstrlen as output(the size of hexstr will be used)  
174. // error: return -1  
175. int YCodec::Wchart2HexStr(wchar_t *wchs, int wchslen, int eachchar, char* hexstr, int* hexstrlen)  
176. {  
177.     if(wchs == NULL || wchslen <= 0 || eachchar <= 0) return -1;  
178.     if(hexstr == NULL){// count the size of hexstr will be used  
179.         *hexstrlen = wchslen*eachchar;  
180.         return 1;  
181.     }  
182.     memset(hexstr, 0, *hexstrlen);  
183.     char* p = hexstr;  
184.     wchar_t* pwch = wchs;  
185.     char* tmp = new char[eachchar+1];  
186.     for(int i=0; i<wchslen; i++){  
187.         // wchar_t to hex  
188.         long hex = Wchart2Hex(*pwch++);  
189.         // hex to char*  
190.         int charlen = 0;  
191.         if(Hex2String(hex, NULL, &charlen) != -1){  
192.             char* str = new char[charlen+1];  
193.             memset(str, 0, charlen+1);  
194.             int n = Hex2String(hex, str, &charlen);  
195.             if(n != -1){  
196.                 int k=0;  
197.                 memset(tmp, 0, eachchar+1);  
198.                 for(k=0; k<eachchar-charlen; k++)    tmp[k] = '0';  
199.                 tmp = strcat(tmp, str);  
200.                 p = strcat(p, tmp);  
201.             }  
202.             if(str) delete []str;  
203.         }  
204.         if(i > *hexstrlen)   break;  
205.     }  
206.     if(tmp) delete []tmp;  
207.   
208.     return 1;  
209. }  

中英文转unicode十六进制字符串实例：

[cpp]  view plain  copy

1. CString input;  
2. m_Input.GetWindowTextW(input);  
3. CString tmp;  
4. YCodec yCodec;  
5.   
6. // CString to wchar_t*  
7. int len = input.GetLength();  
8. wchar_t* wchs = new wchar_t[len+1];  
9. memset(wchs, 0, sizeof(wchar_t)*(len+1));  
10. wcscpy(wchs, input.GetBuffer(len) );  
11. // wchar_t* to hex string  
12. int hexlen = 0;  
13. if(yCodec.Wchart2HexStr(wchs, len, 4, NULL, &hexlen) != -1){  
14.     char* hexstr = new char[hexlen+1];  
15.     memset(hexstr, 0, hexlen+1);  
16.     int n = yCodec.Wchart2HexStr(wchs, len, 4, hexstr, &hexlen);  
17.     if(n != -1){  
18.         // char* to CString  
19.         char* p = hexstr;  
20.         for(int i=0; i<hexlen; i++)  tmp.AppendChar(*p++);  
21.     }  
22.     if(hexstr)  delete []hexstr;  
23. }  
24.   
25. if(wchs)    delete []wchs;  
26.   
27. m_Disp.SetWindowTextW(tmp);  

该功能时在MFC程序中测试的。可以做到如下效果：

输入字符串“中文English“ 转换后输出 ”4e2d65870045006e0067006c006900730068“字符串，每个中文或英文转成4个char类型数据。

unicode十六进制字符串转中英文实例：

[cpp]  view plain  copy

1. <span style="white-space:pre">  </span>CString input;  
2.     m_Input.GetWindowTextW(input);  
3.   
4.     CString tmp;  
5.   
6.     YCodec yCodec;  
7.   
8.     // CString to char*  
9.     int strlen = input.GetLength();  
10.     char* str = new char[strlen+1];  
11.     memset(str, 0, strlen+1);  
12.     for(int i=0; i<strlen; i++)  str[i] = input.GetAt(i);  
13.     // hex string to wchar_t*  
14.     int wchslen = 0;  
15.     if(yCodec.HexStr2WChars(str, strlen, 4, NULL, &wchslen) != -1){  
16.         wchar_t* wchs = new wchar_t[wchslen+1];  
17.         memset(wchs, 0, sizeof(wchar_t)*(wchslen+1));  
18.         int n = yCodec.HexStr2WChars(str, strlen, 4, wchs, &wchslen);  
19.         if(n != -1){  
20.             // wchar_t to CString  
21.             wchar_t* pwch = wchs;  
22.             for(int i=0; i<wchslen; i++) tmp.AppendChar(*pwch++);  
23.         }  
24.         if(wchs)    delete []wchs;  
25.     }  
26.   
27.   
28.     m_Disp.SetWindowTextW(tmp);  

输入字符串 ”4e2d65870045006e0067006c006900730068“转换后输出“中文English“ 字符串，每4个char类型数据转成1个中文或英文。

上述代码经测试可行，暂时没发现什么问题。

测试程序及源码：（不用分下载）

http://download.csdn.net/detail/brantyou/4241745

int ReplaceStr(char* sSrc, char* sMatchStr, char* sReplaceStr)
{
        int StringLen;
        char caNewString[64];
        char* FindPos;
        FindPos =(char *)strstr(sSrc, sMatchStr);
        if( (!FindPos) || (!sMatchStr) )
                return -1;

        while( FindPos )
        {
                memset(caNewString, 0, sizeof(caNewString));
                StringLen = FindPos - sSrc;
                strncpy(caNewString, sSrc, StringLen);
                strcat(caNewString, sReplaceStr);
                strcat(caNewString, FindPos + strlen(sMatchStr));
                strcpy(sSrc, caNewString);

                FindPos =(char *)strstr(sSrc, sMatchStr);
        }
        free(FindPos);
        return 0;
}

譬如：ReplaceStr("abcd-efgh-ijklm-nopq","-","");//把字符串中的“-”删除掉！

 

C++及C语言字符串反转

2016-07-12 23:08  678人阅读  评论(0)  收藏  举报

版权声明：本文为博主原创文章，未经博主允许不得转载。

【C风格字符串反转】
自定义函数：
C语言中所谓的字符串不过是字符数组，后跟一个0x00字符标识结尾，所以反转起来很容易，只要一个循环依次将第一个字符和最后一个字符交换，第二个字符和倒数第二个字符交换……如果最中间有两个字符（即需要反转的字符串长度为偶数），那就交换，如果最中间有一个字符（即需要反转的字符串长度为奇数），那就不需要碰它。还有就是最后一个用来标识字符串结尾的0x00字符不用动它。
注意四点：一是对指针和字符串的理解，二是是否进行合法性检查，例如输入参数为空指针时是否进行检查，三是返回值是否是恰当，即使你通过参数返回了反转后的字符串指针，也建议在返回值里再返回一下，就像strcpy函数实现的那样。其实还有第四点往往是大家都忽略了的，那就是Unicode问题，如果传入的字符串指针指向的是Unicode字符串，那么反转的时候就不能一个字符一个字符的处理了。

[cpp]  view plain  copy

 

1. char *revstr(char *str, size_t len)  
2. {  
3.     char    *start = str;  
4.     char    *end = str + len - 1;  
5.     char    ch;  
6.     if (str != NULL)  
7.     {  
8.         while (start < end)  
9.         {  
10.             ch = *start;  
11.             *start++ = *end;  
12.             *end-- = ch;  
13.         }  
14.     }  
15.     return str;  
16. }  

【C++ string字符串反转】
当然string字符串的反转也可以使用上面的方法来实现，此外还可以使用STL<algorithm>文件里的reverse（）函数来实现。

[cpp]  view plain  copy

 

1. #include <iostream>  
2. #include <algorithm>  
3. #include<cstdlib>  
4. #include<cstring>  
5. using namespace std;  
6. int main()  
7. {  
8.     string ss = "123456";  
9.     reverse(ss.begin(),ss.end());  
10.     cout<<ss<<endl;  
11.     return 0;  
12. }