求助

pkqbszs

1. char *append_result(char *result, char ch)
   
2. {
   
3.         char *last = result;
   
4.         int limit = 0;
   
5.         int times = 1;
   
6. 
   
7.         // 定位到字符串的末尾
   
8.         while(last[limit++] != '\0')
   
9.         {
   
10.                 if(limit >= INCREMENT)
    
11.                 {
    
12.                         limit = 0;
    
13.                         times++;
    
14.                         last += INCREMENT;
    
15.                 }
    
16.         }
    
17. 
    
18.         last[limit - 1] = ch;
    
19.         if(limit >= INCREMENT)
    
20.         {
    
21.                 int offset = last - result;
    
22.                 result = (char *)realloc(result, INIT_SIZE + INCREMENT * times);
    
23.                 last = result;
    
24.                 last += offset;
    
25.                 last += INCREMENT;
    
26.                 limit = 0;                // reset
    
27.         }
    
28.         last[limit] = '\0';
    
29. 
    
30.         return result;
    
31. }
    
32. 
    
33. // 将两个字符串对应的数值相加
    
34. char *add_two_strs(char *str1, char *str2)
    
35. {
    
36.         int carry = 0; // 存放进位
    
37.         int num1, num2, num3;
    
38.         char *result;
    
39. 
    
40.         result = (char *)malloc(INIT_SIZE);
    
41.         if(result == NULL)
    
42.         {
    
43.                 exit(1);
    
44.         }
    
45. 
    
46.         result[0] = '\0';                // 需要 '\0'
    
47. 
    
48.         // 字符串的存放顺序跟加法规则相反
    
49.         // 需要先反转字符串
    
50.         str1 = reverse_str(str1);
    
51.         str2 = reverse_str(str2);
    
52. 
    
53.         // 两个字符串按位相加
    
54.         while(*str1 != '\0' || *str2 != '\0')
    
55.         {
    
56.                 num1 = *str1 - '0';
    
57.                 num2 = *str2 - '0';
    
58. 
    
59.                 if(*str1 == '\0')
    
60.                 {
    
61.                         num1 = 0;
    
62.                 }
    
63.                 else
    
64.                 {
    
65.                         str1++;
    
66.                 }
    
67. 
    
68.                 if(*str2 == '\0')
    
69.                 {
    
70.                         num2 = 0;
    
71.                 }
    
72.                 else
    
73.                 {
    
74.                         str2++;
    
75.                 }
    
76. 
    
77.                 num3 = num1 + num2 + carry;
    
78.                 if(num3 > 9)
    
79.                 {
    
80.                         result = append_result(result, num3 - 10 + '0');
    
81.                         carry = 1;
    
82.                 }
    
83.                 else
    
84.                 {
    
85.                         result = append_result(result, num3 + '0');
    
86.                         carry = 0;
    
87.                 }
    
88.         }
    
89.    
    
90.         if(carry)
    
91.         {
    
92.                 append_result(result, carry + '0');
    
93.         }
    
94. 
    
95.         result = reverse_str(result);
    
96. 
    
97.         return result;
    
98. }
    
99. 
    
100. int main(void)
     
101. {
     
102.         char *num1;
     
103.         char *num2;
     
104.         char *result;
     
105. 
     
106.         num1 = get_num();//该函数将输入的数字以字符类型传入指针数组
     
107.         num2 = get_num();
     
108. 
     
109.         result = add_two_strs(num1, num2);
     
110.         printf("计算结果是：%s\n", result);
     
111. 
     
112.         return 0;  
     
113. }

复制代码

这段代码我想问一下是怎么实现定位到字符串末尾的，result指针定义之后也没有赋值，那last【limit】又有什么意义呢

1. // 定位到字符串的末尾
   
2.         while(last[limit++] != '\0')
   
3.         {
   
4.                 if(limit >= INCREMENT)
   
5.                 {
   
6.                         limit = 0;
   
7.                         times++;
   
8.                         last += INCREMENT;
   
9.                 }
   
10.         }

复制代码

学习编程中的Ben

看不懂啊

两手空空儿

1. // 定位到字符串的末尾
   
2.         while(last[limit++] != '\0')    //找到\0的位置就是末尾了，只不过它记录位置的方法是通过 INCRMENT * time + limit 的方式
   
3.         {
   
4.                 if(limit >= INCREMENT)
   
5.                 {
   
6.                         limit = 0;
   
7.                         times++;
   
8.                         last += INCREMENT;
   
9.                 }
   
10.         }

复制代码

1. if(limit >= INCREMENT)
   
2.         {
   
3.                 int offset = last - result;
   
4.                 result = (char *)realloc(result, INIT_SIZE + INCREMENT * times);   
   
5.                                 //这里用的是realloc，result被重新分配内存以后，原来的内容会被复制到新的内存单元中，所以这里result指向的内容和原来的内容是一样的，
   
6.                                 // last[limit]修改的内容就是result指向的内容
   
7.                 last = result;
   
8.                 last += offset;
   
9.                 last += INCREMENT;
   
10.                 limit = 0;                // reset
    
11.         }
    
12.         last[limit] = '\0';

复制代码