strcopy、strcat

`strcpy` 和 `strcat` 是 C 语言中的两个字符串处理函数，用于处理字符串。

`strcpy` 函数用于复制源字符串（字符串常量或字符数组）到目标字符串（另一个字符数组）。它的原型如下：

char *strcpy(char *dest, const char *src);

其中，`dest` 是目标字符串的地址，`src` 是源字符串的地址。这个函数会将 `src` 中的所有字符复制到 `dest` 中，直到遇到空字符（'\0'）为止。如果 `dest` 没有足够的空间存储 `src`，那么会发生缓冲区溢出，这是非常危险的。

`strcat` 函数用于连接两个字符串。它接受两个参数：一个目标字符串和一个源字符串。它会将 `src` 附加到 `dest` 的末尾，并在目标字符串的末尾添加空字符。这个函数不能在没有足够空间的字符数组上使用，否则会导致缓冲区溢出。它的原型如下：

char *strcat(char *dest, const char *src);

注意，使用 `strcat` 之前，应确保目标字符串以空字符结尾。通常的做法是在使用 `strcat` 之前调用 `strcpy` 或手动添加空字符。

这两个函数通常一起使用，先使用 `strcpy` 复制一个字符串到目标数组，然后再使用 `strcat` 将另一个字符串附加到目标数组的末尾。这样可以确保目标数组有足够的空间来保存两个字符串，并且不会发生缓冲区溢出。

相关问题

strcopy与strcat函数

`strcpy`和`strcat`都是C语言中的字符串操作函数。

`strcpy`函数用于将一个字符串复制到另一个字符串中。它的函数原型为：

char* strcpy(char* dest, const char* src);

其中，`dest`是目标字符串的指针，`src`是源字符串的指针。函数会将源字符串中的内容复制到目标字符串中，并返回目标字符串的指针。

例如：

char src[] = "hello";
char dest[10];
strcpy(dest, src);
printf("%s", dest);  // 输出 hello

`strcat`函数用于将一个字符串连接到另一个字符串的末尾。它的函数原型为：

char* strcat(char* dest, const char* src);

其中，`dest`是目标字符串的指针，`src`是要连接的字符串的指针。函数会将源字符串中的内容连接到目标字符串的末尾，并返回目标字符串的指针。

例如：

char str1[10] = "hello";
char str2[] = "world";
strcat(str1, str2);
printf("%s", str1);  // 输出 helloworld

需要注意的是，`strcat`函数会将源字符串中的内容直接连接到目标字符串的末尾，所以需要确保目标字符串有足够的空间来存储连接后的字符串。否则会导致内存溢出或者其他错误。

假设以单链表结构表示串，每个结点数据域存放一个字符，且附设头结点。编写算法，实现串的下列操作：StrAsign(S,chars);StrCopy(S,T);StrCompare(S,T);StrLength(S);StrCat(S,T);SubString(Sun,S,pos,len)。C语言

下面是基于单链表结构实现串操作的算法，注意代码中的注释。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义链表结点
typedef struct ListNode {
    char data;
    struct ListNode *next;
} ListNode;

// 定义头结点
typedef struct {
    ListNode *head;
    int length;
} LString;

// 初始化串
void StrAssign(LString *S, char *chars) {
    // 新建头结点
    S->head = (ListNode *)malloc(sizeof(ListNode));
    S->head->next = NULL;
    S->length = 0;
    // 如果 chars 不为空，则将每个字符插入到链表中
    if (chars != NULL) {
        ListNode *p = S->head;
        while (*chars != '\0') {
            ListNode *node = (ListNode *)malloc(sizeof(ListNode));
            node->data = *chars;
            node->next = NULL;
            p->next = node;
            p = node;
            chars++;
            S->length++;
        }
    }
}

// 复制串 T 到 S 中
void StrCopy(LString *S, LString *T) {
    ListNode *p = T->head->next;
    // 如果 T 不为空，则将其每个字符插入到 S 中
    while (p != NULL) {
        ListNode *node = (ListNode *)malloc(sizeof(ListNode));
        node->data = p->data;
        node->next = NULL;
        S->head->next = node;
        S->length++;
        p = p->next;
    }
}

// 比较串 S 和 T 的大小关系
int StrCompare(LString *S, LString *T) {
    ListNode *p = S->head->next;
    ListNode *q = T->head->next;
    // 逐个比较 S 和 T 的每个字符，直到出现不相等或其中一个串遍历结束
    while (p != NULL && q != NULL) {
        if (p->data < q->data) {
            return -1;
        } else if (p->data > q->data) {
            return 1;
        }
        p = p->next;
        q = q->next;
    }
    if (p == NULL && q == NULL) {
        return 0;
    } else if (p == NULL) {
        return -1;
    } else {
        return 1;
    }
}

// 返回串 S 的长度
int StrLength(LString *S) {
    return S->length;
}

// 将 T 串连接到 S 的末尾
void StrCat(LString *S, LString *T) {
    ListNode *p = S->head;
    // 找到 S 的最后一个结点
    while (p->next != NULL) {
        p = p->next;
    }
    ListNode *q = T->head->next;
    // 将 T 的每个字符插入到 S 的末尾
    while (q != NULL) {
        ListNode *node = (ListNode *)malloc(sizeof(ListNode));
        node->data = q->data;
        node->next = NULL;
        p->next = node;
        p = node;
        S->length++;
        q = q->next;
    }
}

// 返回从字符串 S 的 pos 位置开始的 len 个字符组成的子串
void SubString(LString *Sub, LString *S, int pos, int len) {
    // 如果 pos 不合法，则返回空串
    if (pos < 1 || pos > S->length || len < 0 || pos + len - 1 > S->length) {
        Sub->head = (ListNode *)malloc(sizeof(ListNode));
        Sub->head->next = NULL;
        Sub->length = 0;
        return;
    }
    // 找到从 pos 开始的结点
    ListNode *p = S->head->next;
    for (int i = 1; i < pos; i++) {
        p = p->next;
    }
    // 将 pos 开始的 len 个字符插入到 Sub 中
    ListNode *q = p;
    Sub->head = (ListNode *)malloc(sizeof(ListNode));
    Sub->head->next = NULL;
    Sub->length = 0;
    for (int i = 0; i < len; i++) {
        ListNode *node = (ListNode *)malloc(sizeof(ListNode));
        node->data = q->data;
        node->next = NULL;
        Sub->head->next = node;
        Sub->length++;
        q = q->next;
    }
}

int main() {
    LString S, T, Sub;
    char *s = "hello";
    char *t = "world";
    char *sub = "llo";
    StrAssign(&S, s);
    StrAssign(&T, t);
    StrAssign(&Sub, sub);
    printf("S: ");
    ListNode *p = S.head->next;
    while (p != NULL) {
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");
    printf("T: ");
    p = T.head->next;
    while (p != NULL) {
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");
    printf("Sub: ");
    p = Sub.head->next;
    while (p != NULL) {
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");
    printf("StrCompare(S, T): %d\n", StrCompare(&S, &T));
    printf("StrLength(S): %d\n", StrLength(&S));
    StrCat(&S, &T);
    printf("StrCat(S, T): ");
    p = S.head->next;
    while (p != NULL) {
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");
    SubString(&Sub, &S, 3, 5);
    printf("SubString(S, 3, 5): ");
    p = Sub.head->next;
    while (p != NULL) {
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");
    return 0;
}