不借用字符串库函数连接字符串

Ranbo_

1.不借用任何字符串库函数实现接受两个字符串，然后把它们连接起来并输出。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. int main()
   
5. {
   
6.     char str1[110] = {0}, str2[110] = {0};//输入两个字符串，初始化
   
7.     char lj[250] = {0};//连接两个字符串，初始化
   
8.     while(scanf("%s %s", str1, str2) != EOF)
   
9.     {
   
10.         int i = 0, j = 0;//i用于str1的复制。并记录str1的长度，j用于继续复制str2
    
11.         while(str1[i] != '\0')
    
12.         {
    
13.             lj[i] = str1[i];
    
14.             i++;
    
15.         }//结束时将str1完整复制到了lj里，i = strlen(str1)
    
16.         while(str2[j] != '\0')
    
17.         {
    
18.             lj[i] = str2[j];
    
19.             i++;    j++;
    
20.         }
    
21.         
    
22.         printf("%s\n",lj);
    
23.     }
    
24.    
    
25.     return 0;
    
26. }

复制代码

2.不借用任何字符串库函数实现无冗余地接受两个字符串，然后把它们无冗余的连接起来并输出。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. /**
   
5. *如果要无冗余，就不能使用数组，需要动态分配内存空间
   
6. */
   
7. int main()
   
8. {
   
9.     char *p;//p接受字符串的单个字符
   
10.     p = (char *) malloc(sizeof(char));
    
11.     while((*p = getchar()) != ' ')
    
12.     {
    
13.         putchar(*p);
    
14.     }//遇到空格退出循环
    
15.     while((*p = getchar()) == ' ');//若继续输入空格则一直循环直到输入非空格字符
    
16.     putchar(*p);//若p不为空格，此时已经接收了一个第二个字符串的非空格字符，先将其输出
    
17.     while((*p = getchar()) != '\n')
    
18.     {
    
19.         putchar(*p);
    
20.     }//继续输出第二个字符串的剩下字符直到输入换行符
    
21.     free(p);
    
22. }
    

复制代码

或者将两个字符串直接连接：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. int main()
   
5. {
   
6.     int i = 1, j = 1, k;
   
7.     char * p1 = (char *)malloc(sizeof(char));
   
8.     char * p2 = (char *)malloc(sizeof(char));
   
9.     char p;
   
10.     while((p = getchar()) != ' ')
    
11.     {
    
12.         p1 = (char *)realloc(p1, sizeof(char) * i);//预留一个空间放结束符
    
13.         *(p1 + i - 1) = p;
    
14.         i++;
    
15.     }//输入啥都给p1，直到遇到空格
    
16.     p1 = (char *)realloc(p1, sizeof(char) * i);
    
17.     *(p1 + i - 1) = '\0';//p1最后一个字符置为'\0'
    
18.    
    
19.     while((p = getchar()) == ' ');//若继续输入空格则一直循环直到输入非空格字符
    
20.     p2 = (char *)realloc(p2, sizeof(char));
    
21.     *p2 = p;
    
22.     while((p = getchar()) != '\n')
    
23.     {
    
24.         p2 = (char *)realloc(p2, sizeof(char) * (j + 1));//p2已经有一个字符放进去了，并需要预留一个空间放结束符
    
25.         *(p2 + j) = p;
    
26.         j++;
    
27.     }
    
28.     p2 = (char *)realloc(p2, sizeof(char) * (j + 1));
    
29.     *(p2 + j) = '\0';                                                   //p2最后一个字符置为'\0'
    
30.     p1 = (char *)realloc(p1,sizeof(char) * (i + j + 1));
    
31.     for(k = 0; k < j + 1; k++, i++)
    
32.     {
    
33.         *(p1 + i - 1) = *(p2 + k);
    
34.     }//将p2的字符串复制到p1里，覆盖p1的'\0'
    
35.     printf("%s", p1);
    
36.     free(p1);
    
37.     free(p2);
    
38.     return 0;
    
39. }
    
40. 
    
41. /*如果默认只有一个空格，那么不需要判断多空格的情况，这个时候稍微改一下j的值可以稍微简化一下程序*/
    

复制代码

如果默认两个字符串之间只有一个空格：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. int main()
   
5. {
   
6.     int i = 1, j = 1, k;
   
7.     char * p1 = (char *)malloc(sizeof(char));
   
8.     char * p2 = (char *)malloc(sizeof(char));
   
9.     char p;
   
10.     while((p = getchar()) != ' ')
    
11.     {
    
12.         p1 = (char *)realloc(p1, sizeof(char) * i);//预留一个空间放结束符
    
13.         *(p1 + i - 1) = p;
    
14.         i++;
    
15.     }//输入啥都给p1，直到遇到空格
    
16.     p1 = (char *)realloc(p1, sizeof(char) * i);
    
17.     *(p1 + i - 1) = '\0';//p1最后一个字符置为'\0'
    
18.    
    
19.     while((p = getchar()) != '\n')
    
20.     {
    
21.         p2 = (char *)realloc(p2, sizeof(char) * (j + 1));//p2已经有一个字符放进去了，并需要预留一个空间放结束符
    
22.         *(p2 + j) = p;
    
23.         j++;
    
24.     }
    
25.     p2 = (char *)realloc(p2, sizeof(char) * j);
    
26.     *(p2 + j - 1) = '\0';                                                   //p2最后一个字符置为'\0'
    
27.     p1 = (char *)realloc(p1,sizeof(char) * (i + j - 1));
    
28.     for(k = 0; k < j ; k++, i++)
    
29.     {
    
30.         *(p1 + i - 1) = *(p2 + k);
    
31.     }//将p2的字符串复制到p1里，覆盖p1的'\0'
    
32.     printf("%s", p1);
    
33.     free(p1);
    
34.     free(p2);
    
35.     return 0;
    
36. }
    

复制代码