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

接着上面的例子来，比如给定字符串"    10522545459"，除去空格有11位，而MAX_INT，即2147483647是10位数，当扫描到最后一个字符‘9’的时候，程序会比较 9 和 2147483647 - 1052254545*10的大小。

也就是说，对于字符串"10522545459", 当扫描到最后一个字符‘9’时，根据上文第1小节的字符串转换成整数的思路：“每扫描到一个字符，我们便把在之前得到的数字乘以10，然后再加上当前字符表示的数字”，为了得到最终的整数，我们得如此计算：

1052254545*10 + 4，

然实际上当程序计算到1052254545*10时，

1052254545*10 >

2147483647

此时已经溢出了,若再执意计算，则程序逻辑将出错，故此后也就不能再判断字串的最后一位4是否大于2147483647%10了（耐不得烦想尽快看到最终正确代码的读者可以直接跳到下文第8节）。

1. //copyright@fuwutu 2013/5/29
2. int StrToInt(const char* str)
3. {
4. bool negative = false;
5. long long result = 0;
6. while (*str == ' ' || *str == '\t')
7. {
8. ++str;
9. }
10. if (*str == '-')
11. {
12. negative = true;
13. ++str;
14. }
15. else if (*str == '+')
16. {
17. ++str;
18. }
19. while (*str != '\0')
20. {
21. int n = *str - '0';
22. if (n < 0 || n > 9)
23. {
24. break;
25. }
26. if (negative)
27. {
28. result = result * 10 - n;
29. if (result < -2147483648LL)
30. {
31. result = -2147483648LL;
32. }
33. }
34. else
35. {
36. result = result * 10 + n;
37. if (result > 2147483647LL)
38. {
39. result = 2147483647LL;
40. }
41. }
42. ++str;
43. }
44. return result;
45. }

1. long long result = 0;

1. //atol函数
2. //Copyright (c) 1989-1997, Microsoft Corporation. All rights reserved.
3. long __cdecl atol(
4. const char *nptr
5. )
6. {
7. int c; /* current char */
8. long total; /* current total */
9. int sign; /* if ''-'', then negative, otherwise positive */
10. /* skip whitespace */
11. while ( isspace((int)(unsigned char)*nptr) )
12. ++nptr;
13. c = (int)(unsigned char)*nptr++;
14. sign = c; /* save sign indication */
15. if (c == ''-'' || c == ''+'')
16. c = (int)(unsigned char)*nptr++; /* skip sign */
17. total = 0;
18. while (isdigit(c)) {
19. total = 10 * total + (c - ''0''); /* accumulate digit */
20. c = (int)(unsigned char)*nptr++; /* get next char */
21. }
22. if (sign == ''-'')
23. return -total;
24. else
25. return total; /* return result, negated if necessary */
26. }

1. isspace(int x)
2. {
3. if(x==' '||x=='/t'||x=='/n'||x=='/f'||x=='/b'||x=='/r')
4. return 1;
5. else
6. return 0;
7. }
8. isdigit(int x)
9. {
10. if(x<='9'&&x>='0')
11. return 1;
12. else
13. return 0;
14. }

但很遗憾的是，上述atoi标准代码依然返回的是long：

再者，下面这里定义成long的total与10相乘，即total*10很容易溢出：

1. simple_strtol，把一个字符串转换为一个有符号长整数；
2. simple_strtoll，把一个字符串转换为一个有符号长长整数；
3. simple_strtoul，把一个字符串转换为一个无符号长整数；
4. simple_strtoull，把一个字符串转换为一个无符号长长整数

然后，上面的strtol调下面的strtoul：

接着，上面的strtoul调下面的strtoull：

最后，strtoull调_parse_integer_fixup_radix和_parse_integer来处理相关逻辑：

重头戏来了。接下来，我们来看上面strtoull函数中的parse_integer_fixup_radix和_parse_integer两段代码。如鲨鱼所说

• “真正的处理逻辑主要是在_parse_integer里面，关于溢出的处理，_parse_integer处理的很优美，
• 而_parse_integer_fixup_radix是用来自动根据字符串判断进制的”。

1. 上头出现了个unlikely，其实unlikely和likely经常出现在linux相关内核源码中
   1. if(likely(value)){
   2. //等价于if(likely(value)) == if(value)
   3. }
   4. else{
   5. }

   likely表示value为真的可能性更大，而unlikely表示value为假的可能性更大，这两个宏被定义成：

   1. //include/linux/compiler.h
   2. # ifndef likely
   3. #  define likely(x) (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 1))
   4. # endif
   5. # ifndef unlikely
   6. #  define unlikely(x)   (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 0))
   7. # endif
2. 呈现下div_u64的代码：
   1. //include/linux/math64.h
   2. //div_u64
   3. static inline u64 div_u64(u64 dividend, u32 divisor)
   4. {
   5. u32 remainder;
   6. return div_u64_rem(dividend, divisor, &remainder);
   7. }
   8. //div_u64_rem
   9. static inline u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)
   10. {
   11. *remainder = dividend % divisor;
   12. return dividend / divisor;
   13. }

2147483647 : 2147483647
2147483648 : -2147483648
10522545459 : 1932610867
-2147483648 : -2147483648
-2147483649 : -2147483647
-10522545459 : 1932610867

8、根据我们第1小节达成一致的字符串转换成整数的思路：“每扫描到一个字符，我们便把在之前得到的数字乘以10，然后再加上当前字符表示的数字”，相信读者已经觉察到，在扫描到最后一个字符的时候，如果之前得到的数比较大，此时若再让其扩大10倍，相对来说是比较容易溢出的。

输入            输出
10522545459  : 2147483647
-10522545459 : -2147483648
2147483648   : 2147483647
-2147483648  : -2147483648

1. 00077 #include <compiler.h>
2. 00078 #include <stdlib.h>
3. 00079
4. 00084
5. 00092 int atoi(CONST char *str)
6. 00093 {
7. 00094     return ((int) strtol(str, (char **) NULL, 10));
8. 00095 }

1. #include <errno.h>
2. #include <stdio.h>
3. #include <ctype.h>
4. #include <limits.h>
5. #define CONST      const
6. long mstrtol(CONST char *nptr, char **endptr, int base)
7. {
8. register CONST char *s;
9. register long acc, cutoff;
10. register int c;
11. register int neg, any, cutlim;
12. /*
13. * Skip white space and pick up leading +/- sign if any.
14. * If base is 0, allow 0x for hex and 0 for octal, else
15. * assume decimal; if base is already 16, allow 0x.
16. */
17. s = nptr;
18. do {
19. c = (unsigned char) *s++;
20. } while (isspace(c));
21. if (c == '-') {
22. neg = 1;
23. c = *s++;
24. } else {
25. neg = 0;
26. if (c == '+')
27. c = *s++;
28. }
29. if ((base == 0 || base == 16) && c == '0' && (*s == 'x' || *s == 'X')) {
30. c = s[1];
31. s += 2;
32. base = 16;
33. }
34. if (base == 0)
35. base = c == '0' ? 8 : 10;
36. /*
37. * Compute the cutoff value between legal numbers and illegal
38. * numbers.  That is the largest legal value, divided by the
39. * base.  An input number that is greater than this value, if
40. * followed by a legal input character, is too big.  One that
41. * is equal to this value may be valid or not; the limit
42. * between valid and invalid numbers is then based on the last
43. * digit.  For instance, if the range for longs is
44. * [-2147483648..2147483647] and the input base is 10,
45. * cutoff will be set to 214748364 and cutlim to either
46. * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
47. * a value > 214748364, or equal but the next digit is > 7 (or 8),
48. * the number is too big, and we will return a range error.
49. *
50. * Set any if any `digits' consumed; make it negative to indicate
51. * overflow.
52. */
53. cutoff = neg ? LONG_MIN : LONG_MAX;
54. cutlim = cutoff % base;
55. cutoff /= base;
56. if (neg) {
57. if (cutlim > 0) {
58. cutlim -= base;
59. cutoff += 1;
60. }
61. cutlim = -cutlim;
62. }
63. for (acc = 0, any = 0;; c = (unsigned char) *s++) {
64. if (isdigit(c))
65. c -= '0';
66. else if (isalpha(c))
67. c -= isupper(c) ? 'A' - 10 : 'a' - 10;
68. else
69. break;
70. if (c >= base)
71. break;
72. if (any < 0)
73. continue;
74. if (neg) {
75. if ((acc < cutoff || acc == cutoff) && c > cutlim) {
76. any = -1;
77. acc = LONG_MIN;
78. errno = ERANGE;
79. } else {
80. any = 1;
81. acc *= base;
82. acc -= c;
83. }
84. } else {
85. if ((acc > cutoff || acc == cutoff) && c > cutlim) {
86. any = -1;
87. acc = LONG_MAX;
88. errno = ERANGE;
89. } else {
90. any = 1;
91. acc *= base;
92. acc += c;
93. }
94. }
95. }
96. if (endptr != 0)
97. *endptr = (char *) (any ? s - 1 : nptr);
98. return (acc);
99. }
100. int matoi2(CONST char *str)
101. {
102. return ((int) mstrtol(str, (char **) NULL, 10));
103. }
104. int mgetline(char* buf, size_t n) {
105. size_t idx = 0;
106. int c;
107. while (--n > 0 && (c = getchar()) != EOF && c != '\n') {
108. buf[idx++] = c;
109. }
110. buf[idx] = '\0';
111. return idx;
112. }
113. #define MAX_LINE 200
114. int main() {
115. char buf[MAX_LINE];
116. while (mgetline(buf, MAX_LINE) >= 0) {
117. if (strcmp(buf, "quit") == 0) break;
118. printf("matoi2=%d\n", matoi2(buf));
119. }
120. return 0;
121. }

1. if (neg) {
2. if ((acc < cutoff || acc == cutoff) && c > cutlim) {
3. any = -1;
4. acc = LONG_MIN;
5. errno = ERANGE;
6. } else {
7. any = 1;
8. acc *= base;
9. acc -= c;
10. }
11. } else {
12. if ((acc > cutoff || acc == cutoff) && c > cutlim) {
13. any = -1;
14. acc = LONG_MAX;
15. errno = ERANGE;

1. if ((acc > cutoff || acc == cutoff) && c > cutlim)

1. if ( acc > cutoff ||  (acc == cutoff) && c > cutlim)  )

1. if ((acc < cutoff || acc == cutoff) && c > cutlim) {

1. if (acc < cutoff || (acc == cutoff && c > cutlim)) {

1. 一种是诸如2147483650，即n > MAX/10 的；
2. 一种是诸如2147483649，即n == MAX/10 && c > MAX%10。”

1. if (sign > 0 && (n > MAX/10 || (n == MAX/10 && c > MAX%10)))
2. {
3. n = MAX;
4. break;
5. }
6. else if (sign < 0 && (n > (unsigned)MIN/10
7. || (n == (unsigned)MIN/10 && c > (unsigned)MIN%10)))
8. {
9. n = MIN;
10. break;
11. }

1. //copyright@cao_peng 2013/4/23
2. int str_len(char *a) {  //字符串长度
3. if (a == 0) {
4. return 0;
5. }
6. char *t = a;
7. for (;*t;++t)
8. ;
9. return (int) (t - a);
10. }
11. void str_copy(char *a,const char *b,int len) {  //拷贝字符串 a = b
12. for (;len > 0; --len, ++b,++a) {
13. *a = *b;
14. }
15. *a = 0;
16. }
17. char *str_join(char *a,const char *b,int lenb) { //连接字符串 第一个字符串被回收
18. char *t;
19. if (a == 0) {
20. t = (char *) malloc(sizeof(char) * (lenb + 1));
21. str_copy(t, b, lenb);
22. return t;
23. }
24. else {
25. int lena = str_len(a);
26. t = (char *) malloc(sizeof(char) * (lena + lenb + 2));
27. str_copy(t, a, lena);
28. *(t + lena) = ' ';
29. str_copy(t + lena + 1, b, lenb);
30. free(a);
31. return t;
32. }
33. }
34. int canMatch(char *input, char *rule) { // 返回最长匹配长度 -1表示不匹配　
35. if (*rule == 0) { //已经到rule尾端
36. return 0;
37. }
38. int r = -1 ,may;
39. if (*rule == '*') {
40. r = canMatch(input, rule + 1);  // *匹配0个字符
41. if (*input) {
42. may = canMatch(input + 1, rule);  // *匹配非0个字符
43. if ((may >= 0) && (++may > r)) {
44. r = may;
45. }
46. }
47. }
48. if (*input == 0) {  //到尾端
49. return r;
50. }
51. if ((*rule == '?') || (*rule == *input)) {
52. may = canMatch(input + 1, rule + 1);
53. if ((may >= 0) && (++may > r)) {
54. r = may;
55. }
56. }
57. return r;
58. }
59. char * my_find(char  input[],   char rule[]) {
60. int len = str_len(input);
61. int *match = (int *) malloc(sizeof(int) * len);  //input第i位最多能匹配多少位 匹配不上是-1
62. int i,max_pos = - 1;
63. char *output = 0;
64. for (i = 0; i < len; ++i) {
65. match[i] = canMatch(input + i, rule);
66. if ((max_pos < 0) || (match[i] > match[max_pos])) {
67. max_pos = i;
68. }
69. }
70. if ((max_pos < 0) || (match[max_pos] <= 0)) {  //不匹配
71. output = (char *) malloc(sizeof(char));
72. *output = 0;   // \0
73. return output;
74. }
75. for (i = 0; i < len;) {
76. if (match[i] == match[max_pos]) { //找到匹配
77. output = str_join(output, input + i, match[i]);
78. i += match[i];
79. }
80. else {
81. ++i;
82. }
83. }
84. free(match);
85. return output;
86. }

1. //copyright@chpeih 2013/4/23
2. char* my_find(char  input[],   char rule[])
3. {
4. //write your code here
5. int len1,len2;
6. for(len1 = 0;input[len1];len1++);
7. for(len2 = 0;rule[len2];len2++);
8. int MAXN = len1>len2?(len1+1):(len2+1);
9. int  **dp;
10. //dp[i][j]表示字符串1和字符串2分别以i j结尾匹配的最大长度
11. //记录dp[i][j]是由之前那个节点推算过来  i*MAXN+j
12. dp = new int *[len1+1];
13. for (int i = 0;i<=len1;i++)
14. {
15. dp[i] = new int[len2+1];
16. }
17. dp[0][0] = 0;
18. for(int i = 1;i<=len2;i++)
19. dp[0][i] = -1;
20. for(int i = 1;i<=len1;i++)
21. dp[i][0] = 0;
22. for (int i = 1;i<=len1;i++)
23. {
24. for (int j = 1;j<=len2;j++)
25. {
26. if(rule[j-1]=='*'){
27. dp[i][j] = -1;
28. if (dp[i-1][j-1]!=-1)
29. {
30. dp[i][j] = dp[i-1][j-1]+1;
31. }
32. if (dp[i-1][j]!=-1 && dp[i][j]<dp[i-1][j]+1)
33. {
34. dp[i][j] = dp[i-1][j]+1;
35. }
36. }else if (rule[j-1]=='?')
37. {
38. if(dp[i-1][j-1]!=-1){
39. dp[i][j] = dp[i-1][j-1]+1;
40. }else dp[i][j] = -1;
41. }
42. else
43. {
44. if(dp[i-1][j-1]!=-1 && input[i-1]==rule[j-1]){
45. dp[i][j] = dp[i-1][j-1]+1;
46. }else dp[i][j] = -1;
47. }
48. }
49. }
50. int m = -1;//记录最大字符串长度
51. int *ans = new int[len1];
52. int count_ans = 0;//记录答案个数
53. char *returnans = new char[len1+1];
54. int count = 0;
55. for(int i = 1;i<=len1;i++)
56. if (dp[i][len2]>m){
57. m = dp[i][len2];
58. count_ans = 0;
59. ans[count_ans++] = i-m;
60. }else if(dp[i][len2]!=-1 &&dp[i][len2]==m){
61. ans[count_ans++] = i-m;
62. }
63. if (count_ans!=0)
64. {
65. int len = ans[0];
66. for (int i = 0;i<m;i++)
67. {
68. printf("%c",input[i+ans[0]]);
69. returnans[count++] = input[i+ans[0]];
70. }
71. for (int j = 1;j<count_ans;j++)
72. {
73. printf(" ");
74. returnans[count++] = ' ';
75. len = ans[j];
76. for (int i = 0;i<m;i++)
77. {
78. printf("%c",input[i+ans[j]]);
79. returnans[count++] = input[i+ans[j]];
80. }
81. }
82. printf("\n");
83. returnans[count++] = '\0';
84. }
85. return returnans;
86. }