博客笔记 字符串是否包含及匹配/查找/转换/拷贝问题

摘自：

程序员编程艺术：第二章、字符串是否包含及匹配/查找/转换/拷贝问题

5.3、字符串转换为整数
题目：输入一个表示整数的字符串，把该字符串转换成整数并输出。
例如输入字符串"345"，则输出整数345。

    分析：此题看起来，比较简单，每扫描到一个字符，我们把在之前得到的数字乘以10再加上当前字符表示的数字。这个思路用循环不难实现。然其背后却隐藏着不少陷阱，正如zhedahht 所说，有以下几点需要你注意：
    1、由于整数可能不仅仅之含有数字，还有可能以'+'或者'-'开头，表示整数的正负。如果第一个字符是'+'号，则不需要做任何操作；如果第一个字符是'-'号，则表明这个整数是个负数，在最后的时候我们要把得到的数值变成负数。
    2、如果使用的是指针的话，在使用指针之前，我们要做的第一件是判断这个指针是不是为空。如果试着去访问空指针，将不可避免地导致程序崩溃（此第2点在下面的程序不需注意，因为没有用到指针）。
    3、输入的字符串中可能含有不是数字的字符。
每当碰到这些非法的字符，我们就没有必要再继续转换。
    4、溢出问题。由于输入的数字是以字符串的形式输入，因此有可能输入一个很大的数字转换之后会超过能够表示的最大的整数而溢出。

    总结以上四点，代码可以如下编写：

1. //字符串转换为整数  
2. //copyright@ yansha  
3. #include <iostream>  
4. #include <string>  
5. using namespace std;  
6.   
7. int str_2_int(string str)  
8. {  
9.     if (str.size() == 0)  
10.         exit(0);  
11.       
12.     int pos = 0;  
13.     int sym = 1;  
14.       
15.     // 处理符号  
16.     if (str[pos] == '+')  
17.         pos++;  
18.     else if (str[pos] == '-')  
19.     {  
20.         pos++;  
21.         sym = -1;  
22.     }  
23.       
24.     int num = 0;  
25.     // 逐位处理  
26.     while (pos < str.length())  
27.     {  
28.         // 处理数字以外的字符  
29.         if (str[pos] < '0' || str[pos] > '9')  
30.             exit(0);  
31.           
32.         num = num * 10 + (str[pos] - '0');  
33.           
34.         // 处理溢出  
35.         if (num < 0)  
36.             exit(0);      
37.         pos++;  
38.     }  
39.       
40.     num *= sym;   
41.     return num;  
42. }  
43.   
44. int main()  
45. {  
46.     string str = "-3450";  
47.     int num = str_2_int(str);  
48.     cout << num << endl;  
49.     return 0;  
50. }  

    @helloword：这个的实现非常不好，当输入字符串参数为非法时，不是抛出异常不是返回error code，而是直接exit了。直接把进程给终止了，想必现实应用中的实现都不会这样。建议您改改，不然拿到面试官那，会被人喷死的。ok，听从他的建议，借用zhedahht的代码了：

1. //http://zhedahht.blog.163.com/blog/static/25411174200731139971/  
2. enum Status {kValid = 0, kInvalid};  
3. int g_nStatus = kValid;  
4.   
5. int StrToInt(const char* str)  
6. {  
7.     g_nStatus = kInvalid;  
8.     long long num = 0;  
9.       
10.     if(str != NULL)  
11.     {  
12.         const char* digit = str;  
13.           
14.         // the first char in the string maybe '+' or '-'  
15.         bool minus = false;  
16.         if(*digit == '+')  
17.             digit ++;  
18.         else if(*digit == '-')  
19.         {  
20.             digit ++;  
21.             minus = true;  
22.         }  
23.           
24.         // the remaining chars in the string  
25.         while(*digit != '/0')  
26.         {  
27.             if(*digit >= '0' && *digit <= '9')  
28.             {  
29.                 num = num * 10 + (*digit - '0');  
30.                   
31.                 // overflow    
32.                 if(num > std::numeric_limits<int>::max())  
33.                 {  
34.                     num = 0;  
35.                     break;  
36.                 }  
37.                   
38.                 digit ++;  
39.             }  
40.             // if the char is not a digit, invalid input  
41.             else  
42.             {  
43.                 num = 0;  
44.                 break;  
45.             }  
46.         }  
47.           
48.         if(*digit == '/0')  
49.         {  
50.             g_nStatus = kValid;  
51.             if(minus)  
52.                 num = 0 - num;  
53.         }  
54.     }  
55.       
56.     return static_cast<int>(num);  
57. }  

updated：yansha看到了上述helloword的所说的后，修改如下：

1. #include <iostream>  
2. #include <string>  
3. #include <assert.h>  
4. using namespace std;  
5.   
6. int str_2_int(string str)  
7. {  
8.     assert(str.size() > 0);  
9.       
10.     int pos = 0;  
11.     int sym = 1;  
12.       
13.     // 处理符号  
14.     if (str[pos] == '+')  
15.         pos++;  
16.     else if (str[pos] == '-')  
17.     {  
18.         pos++;  
19.         sym = -1;  
20.     }  
21.       
22.     int num = 0;  
23.     // 逐位处理  
24.     while (pos < str.length())  
25.     {  
26.         // 处理数字以外的字符  
27.         assert(str[pos] >= '0');  
28.         assert(str[pos] <= '9');  
29.           
30.         num = num * 10 + (str[pos] - '0');  
31.           
32.         // 处理溢出  
33.         assert(num >= 0);  
34.           
35.         pos++;  
36.     }  
37.       
38.     num *= sym;  
39.       
40.     return num;  
41. }  
42.   
43. int main()  
44. {  
45.     string str = "-1024";  
46.     int num = str_2_int(str);  
47.     cout << num << endl;  
48.     return 0;  
49. }  

  

5.4、字符串拷贝
题目描述：
    要求实现库函数strcpy，

原型声明：extern char *strcpy(char *dest,char *src); 
功能：把src所指由NULL结束的字符串复制到dest所指的数组中。 　
说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。 　
返回指向dest的指针。

    分析：如果编写一个标准strcpy函数的总分值为10，下面给出几个不同得分的答案：

1. //2分  
2. void strcpy( char *strDest, char *strSrc )  
3. {  
4.     while( (*strDest++ = * strSrc++) != '/0' );  
5. }   
6.   
7. //4分  
8. void strcpy( char *strDest, const char *strSrc )   
9. {  
10.     //将源字符串加const，表明其为输入参数，加2分  
11.     while( (*strDest++ = * strSrc++) != '/0' );  
12. }   
13.   
14. //7分  
15. void strcpy(char *strDest, const char *strSrc)   
16. {  
17.     //对源地址和目的地址加非0断言，加3分  
18.     assert( (strDest != NULL) && (strSrc != NULL) );  
19.     while( (*strDest++ = * strSrc++) != '/0' );  
20. }   
21.   
22. //10分  
23. //为了实现链式操作，将目的地址返回，加3分！  
24. char * strcpy( char *strDest, const char *strSrc )   
25. {  
26.     assert( (strDest != NULL) && (strSrc != NULL) );  
27.     char *address = strDest;   
28.     while( (*strDest++ = * strSrc++) != '/0' );   
29.     return address;  
30. }   

勘误：上述字符串拷贝的写法有点问题，正如本文评论下留言的读者paranoid2006所述：字符串拷贝的问题，虽然限定源字符串为const，但是不能防止src和dest有overlap，层叠的问题。也就是在拷贝src到dest的中途会导致dest覆盖部分src的字符串。
当dest+strlen(src)大于src或者src+strlen(src)大于dest均有可能导致覆盖。