通过指针传参形式分别实现 mystrcat mystrcmp 以及mystrcpy函数

轻语远歌

通过指针传参形式分别实现 mystrcat  mystrcmp 以及mystrcpy函数

FishC

好的，鱼油同学，以下是使用指针传参形式实现 `mystrcat`（字符串拼接）、`mystrcmp`（字符串比较）和 `mystrcpy`（字符串复制）的示例代码。

### 实现 `mystrcat`

1. #include <stdio.h>
   
2. 
   
3. // 拼接字符串
   
4. char *mystrcat(char *dest, const char *src) {
   
5.     char *p = dest;
   
6. 
   
7.     // 移动到dest的末尾
   
8.     while (*p != '\0') {
   
9.         p++;
   
10.     }
    
11. 
    
12.     // 逐个字符拼接src到dest尾部
    
13.     while (*src != '\0') {
    
14.         *p++ = *src++;
    
15.     }
    
16. 
    
17.     // 添加字符串结束符
    
18.     *p = '\0';
    
19. 
    
20.     return dest;
    
21. }
    
22. 
    
23. int main() {
    
24.     char dest[100] = "Hello, ";
    
25.     char src[] = "World!";
    
26.     mystrcat(dest, src);
    
27.     printf("%s\n", dest); // 输出：Hello, World!
    
28.     return 0;
    
29. }

复制代码

### 实现 `mystrcmp`

1. #include <stdio.h>
   
2. 
   
3. // 比较两个字符串
   
4. int mystrcmp(const char *str1, const char *str2) {
   
5.     while (*str1 && (*str1 == *str2)) {
   
6.         str1++;
   
7.         str2++;
   
8.     }
   
9.     return *(unsigned char *)str1 - *(unsigned char *)str2;
   
10. }
    
11. 
    
12. int main() {
    
13.     char str1[] = "Hello";
    
14.     char str2[] = "Hello";
    
15.     int result = mystrcmp(str1, str2);
    
16.     printf("%d\n", result); // 输出：0 表示相等
    
17.     return 0;
    
18. }

复制代码

### 实现 `mystrcpy`

1. #include <stdio.h>
   
2. 
   
3. // 复制字符串
   
4. char *mystrcpy(char *dest, const char *src) {
   
5.     char *p = dest;
   
6. 
   
7.     // 逐个字符复制
   
8.     while ((*p++ = *src++) != '\0');
   
9. 
   
10.     return dest;
    
11. }
    
12. 
    
13. int main() {
    
14.     char dest[100];
    
15.     char src[] = "Hello, World!";
    
16.     mystrcpy(dest, src);
    
17.     printf("%s\n", dest); // 输出：Hello, World!
    
18.     return 0;
    
19. }

复制代码

希望这段代码能帮助你理解如何通过指针形式实现这些字符串操作函数。如果有任何问题，请随时提问！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

轻语远歌

FishC 发表于 2024-9-16 20:01
好的，鱼油同学，以下是使用指针传参形式实现 `mystrcat`（字符串拼接）、`mystrcmp`（字符串比较）和 `mys ...

第二个实现mystrcmp看不太懂，具体讲解以下或者写的代码参次清晰点

FishC

轻语远歌 发表于 2024-09-16 21:56
第二个实现mystrcmp看不太懂，具体讲解以下或者写的代 ...

好的，鱼油同学，我来详细解释 `mystrcmp` 的实现，并将代码组织得更清晰。

### 实现 `mystrcmp`

`mystrcmp` 函数用于比较两个字符串的大小。它的基本思路是一次比较两个字符串的每个字符，直到遇到不同的字符或到达字符串的结尾。

1. #include <stdio.h>
   
2. 
   
3. // 比较两个字符串
   
4. int mystrcmp(const char *str1, const char *str2) {
   
5.     // 循环比较两个字符串的字符
   
6.     while (*str1 && (*str1 == *str2)) {
   
7.         str1++;
   
8.         str2++;
   
9.     }
   
10.     // 最终返回差值
    
11.     return *(unsigned char *)str1 - *(unsigned char *)str2;
    
12. }
    
13. 
    
14. int main() {
    
15.     char str1[] = "Hello";
    
16.     char str2[] = "Hello";
    
17.     int result = mystrcmp(str1, str2);
    
18. 
    
19.     if (result < 0) {
    
20.         printf("str1 < str2\n");
    
21.     } else if (result > 0) {
    
22.         printf("str1 > str2\n");
    
23.     } else {
    
24.         printf("str1 == str2\n");
    
25.     }
    
26. 
    
27.     return 0;
    
28. }

复制代码

### Explanation（解释）

1. **参数定义**：`const char *str1, const char *str2` 是两个指向待比较字符串的指针。
2. **循环比较**：
   - `while (*str1 && (*str1 == *str2))` 表示循环继续的条件是：当前字符不为 `\0` 且两个字符串的当前字符相同。
   - `str1++` 和 `str2++` 会将指针分别指向下一个字符。
3. **返回值**：
   - 当循环结束时，可能是因为某个字符不同，也可能是到达字符串的结尾。
   - `return *(unsigned char *)str1 - *(unsigned char *)str2;` 这行代码返回两个字符的差值，这个差值可以是：
     - 负值：`str1` 在字典顺序上小于 `str2`
     - 正值：`str1` 在字典顺序上大于 `str2`
     - 零值：`str1` 和 `str2` 相等

举个例子，如果 `str1` 是 "Hello" 而 `str2` 是 "Hello"，函数会返回 `0`，表示它们是相等的。如果 `str1` 是 "Hello" 而 `str2` 是 "Hellp"，函数会返回一个负值，因为 'o' < 'p'。

希望这个解释能帮助你理解 `mystrcmp` 函数。如果有任何进一步的问题，请随时提问！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

ultron110

FishC 发表于 2024-9-16 20:01
好的，鱼油同学，以下是使用指针传参形式实现 `mystrcat`（字符串拼接）、`mystrcmp`（字符串比较）和 `mys ...

mystrcat实现字符串拼接，这个函数名的缩写字母，是怎么体现出拼接这个词的？

FishC

ultron110 发表于 2024-09-16 22:15
mystrcat实现字符串拼接，这个函数名的缩写字母，是怎 ...

fish油同学好，`mystrcat`中的`strcat`是`string concatenate`的缩写，其中 `str` 代表“字符串”(string)，`cat` 代表“拼接”(concatenate)。下面我将完整的 `mystrcat` 实现再展示一下：

### 实现 `mystrcat`

1. #include <stdio.h>
   
2. 
   
3. // 拼接字符串
   
4. char *mystrcat(char *dest, const char *src) {
   
5.     char *p = dest;
   
6. 
   
7.     // 移动到 dest 的末尾
   
8.     while (*p != '\0') {
   
9.         p++;
   
10.     }
    
11. 
    
12.     // 逐个字符拼接 src 到 dest 尾部
    
13.     while (*src != '\0') {
    
14.         *p++ = *src++;
    
15.     }
    
16. 
    
17.     // 添加字符串结束符
    
18.     *p = '\0';
    
19. 
    
20.     return dest;
    
21. }
    
22. 
    
23. int main() {
    
24.     char dest[50] = "Hello, "; // 确保 dest 有足够的空间容纳拼接后的字符串
    
25.     char src[] = "World!";
    
26.     mystrcat(dest, src);
    
27.     printf("%s\n", dest); // 输出：Hello, World!
    
28.     return 0;
    
29. }

复制代码

### 关键解释
- `mystrcat` 将 `src` 字符串拼接到 `dest` 字符串的尾部。
- `strcat` 是 `string concatenate` 的缩写，用于表示字符串拼接操作。

希望这个解释能让你更清楚为什么函数名叫 `mystrcat` 以及其实际功能。 如果还有其它问题，欢迎继续提问！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

轻语远歌

这3个函数不要写那么精简，最好都详细讲解以下代码思路

FishC

轻语远歌 发表于 2024-09-16 22:35
这3个函数不要写那么精简，最好都详细讲解以下代码思 ...

好的，鱼油同学。下面是 `mystrcat`、`mystrcmp` 和 `mystrcpy` 的详细实现及讲解。

### 1. 实现 `mystrcat`
`mystrcat` 函数用于将源字符串拼接到目标字符串的末尾。

1. #include <stdio.h>
   
2. 
   
3. // 字符串拼接函数
   
4. char *mystrcat(char *dest, const char *src) {
   
5.     // 找到目标字符串的末尾
   
6.     char *d = dest;
   
7.     while (*d != '\0') {
   
8.         d++;
   
9.     }
   
10. 
    
11.     // 将源字符串复制到目标字符串的末尾
    
12.     while (*src != '\0') {
    
13.         *d = *src;
    
14.         d++;
    
15.         src++;
    
16.     }
    
17. 
    
18.     // 添加字符串结束符 '\0'
    
19.     *d = '\0';
    
20. 
    
21.     return dest;
    
22. }
    
23. 
    
24. int main() {
    
25.     char dest[50] = "Hello";
    
26.     char src[] = " World";
    
27.    
    
28.     mystrcat(dest, src);
    
29.     printf("%s\n", dest);  // 输出 "Hello World"
    
30.    
    
31.     return 0;
    
32. }

复制代码

### 2. 实现 `mystrcmp`
`mystrcmp` 函数用于比较两个字符串的大小。返回值如下：
- 0：如果两个字符串相等。
- 正值：如果第一个字符串大于第二个字符串。
- 负值：如果第一个字符串小于第二个字符串。

1. #include <stdio.h>
   
2. 
   
3. // 字符串比较函数
   
4. int mystrcmp(const char *str1, const char *str2) {
   
5.     while (*str1 != '\0' && *str2 != '\0' && *str1 == *str2) {
   
6.         str1++;
   
7.         str2++;
   
8.     }
   
9. 
   
10.     // 返回两个字符的差值
    
11.     return *str1 - *str2;
    
12. }
    
13. 
    
14. int main() {
    
15.     char str1[] = "apple";
    
16.     char str2[] = "apricot";
    
17.    
    
18.     int result = mystrcmp(str1, str2);
    
19.     printf("%d\n", result);  // 输出一个负值，因为 'l' < 'r'
    
20.    
    
21.     return 0;
    
22. }

复制代码

### 3. 实现 `mystrcpy`
`mystrcpy` 函数用于将源字符串复制到目标字符串。

1. #include <stdio.h>
   
2. 
   
3. // 字符串复制函数
   
4. char *mystrcpy(char *dest, const char *src) {
   
5.     char *d = dest;
   
6. 
   
7.     // 将源字符串的内容复制到目标字符串
   
8.     while (*src != '\0') {
   
9.         *d = *src;
   
10.         d++;
    
11.         src++;
    
12.     }
    
13. 
    
14.     // 添加字符串结束符 '\0'
    
15.     *d = '\0';
    
16. 
    
17.     return dest;
    
18. }
    
19. 
    
20. int main() {
    
21.     char dest[50];
    
22.     char src[] = "Hello World";
    
23.    
    
24.     mystrcpy(dest, src);
    
25.     printf("%s\n", dest);  // 输出 "Hello World"
    
26.    
    
27.     return 0;
    
28. }

复制代码

### 代码思路讲解
1. **`mystrcat`**：
    - `char *d = dest;`：定义指针 `d` 指向目标字符串的开头。
    - `while (*d != '\0') { d++; }`：找到目标字符串的末尾。
    - `while (*src != '\0') { *d = *src; d++; src++; }`：将源字符串的每个字符复制到目标字符串的末尾。
    - `*d = '\0';`：追加字符串结束符。
    - 返回目标字符串。

2. **`mystrcmp`**：
    - `while (*str1 != '\0' && *str2 != '\0' && *str1 == *str2) { str1++; str2++; }`：逐字节比较两个字符串，直到遇到不同字符或到达字符串末尾。
    - `return *str1 - *str2;`：返回比较结果，差值为两个字符之间的差。

3. **`mystrcpy`**：
    - `char *d = dest;`：定义指针 `d` 指向目标字符串的开头。
    - `while (*src != '\0') { *d = *src; d++; src++; }`：将源字符串的每个字符复制到目标字符串中。
    - `*d = '\0';`：追加字符串结束符。
    - 返回目标字符串。

希望这些详细讲解对你有所帮助，如果有其他问题，随时提问哦！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。