[C语言] string.h相关函数自实现

strlen

/**
 * 计算字符串s的长度
 * @param s 字符串
 * @return 字符串长度
 */
size_t my_strlen(const char *s)
{
    // 遍历字符串s，直到遇到'\0'
    const char *p = s;
    while (*p != '\0')
    {
        // 指针后移
        ++p;
    }
    // 返回字符串长度
    return p - s;
}

strcpy 与 strncpy

/**
 * 将字符串src复制到dest
 * @param dest 目标字符串
 * @param src 源字符串
 * @return 复制后的字符串
 */
char *my_strcpy(char *dest, const char *src)
{
    size_t i;
    // 遍历src字符串，直到遇到'\0'
    for (i = 0; src[i] != '\0'; ++i)
    {
        // 将src字符串中的字符复制到dest字符串中
        dest[i] = src[i];
    }
    // 将dest字符串的最后一个字符设置为'\0'
    dest[i] = '\0';
    // 返回复制后的字符串
    return dest;
}

/**
 * 将字符串src中的前n个字符复制到dest
 * @param dest 目标字符串
 * @param src 源字符串
 * @param n 复制字符的数量
 * @return 复制后的字符串
 */
char *my_strncpy(char *dest, const char *src, size_t n)
{
    size_t i;
    // 将src字符串的前n个字符复制到dest字符串中
    for (i = 0; i < n && src[i] != '\0'; ++i)
    {
        dest[i] = src[i];
    }

    // 如果src字符串的字符数量小于n，将dest字符串的剩余字符设置为\0
    while (i < n)
    {
        dest[i] = '\0';
        ++i;
    }
    return dest;
}

strcat 与 strncat

/**
 * 连接两个字符串
 * @param dest 目标字符串
 * @param src 源字符串
 * @return 连接后的字符串
 */
char *my_strcat(char *dest, const char *src)
{
    // 获取目标字符串的长度
    size_t dest_len = strlen(dest);
    // 定义一个变量i，用于循环
    size_t i;
    // 循环遍历源字符串，将源字符串中的字符添加到目标字符串的末尾
    for (i = 0; src[i] != '\0'; ++i)
    {
        dest[dest_len + i] = src[i];
    }
    // 在连接字符串后添加一个结束符
    dest[dest_len + i] = '\0';
    // 返回连接后的字符串
    return dest;
}

/**
 * 将字符串src中的前n个字符连接到dest字符串的末尾
 * @param dest 目标字符串
 * @param src 源字符串
 * @param n 需要连接的字符数量
 * @return 连接后的字符串
 */
char *my_strncat(char *dest, const char *src, size_t n)
{
    size_t dest_len = strlen(dest);
    size_t i;
    // 将src字符串的前n个字符连接到dest字符串的末尾
    for (i = 0; i < n && src[i] != '\0'; ++i)
    {
        dest[dest_len + i] = src[i];
    }
    // 添加字符串结束符
    dest[dest_len + i] = '\0';
    return dest;
}

strcmp

/**
 * 比较两个字符串s1和s2，并返回比较结果
 * @param s1 字符串s1
 * @param s2 字符串s2
 * @return 比较结果
 */
int my_strcmp(const char *s1, const char *s2)
{
    // 遍历两个字符串，直到遇到不同的字符或者遇到字符串结束符'\0'
    while (*s1 == *s2 && *s1 != '\0')
    {
        s1++;
        s2++;
    }
    // 计算两个字符的ASCII码之差
    int i = *s1 - *s2;
    // 如果两个字符相等，返回0
    if (i == 0)
    {
        return i;
    }
    // 如果s1中的字符大于s2中的字符，返回1；否则返回-1
    return *s1 - *s2 > 0 ? 1 : -1;
}

strchr 与 strrchr

/**
 * 在字符串s中查找第一个字符c的位置，并返回指向该字符的指针
 * @param s 字符串s
 * @param c 字符c
 * @return 指向字符c的指针，如果没有找到则返回NULL
 */
char *my_strchr(const char *s, int c)
{
    // 遍历字符串s
    while (*s != '\0')
    {
        // 如果找到字符c
        if (*s == c)
        {
            // 返回指向字符c的指针
            return (char *) s;
        }
        // 指针后移
        ++s;
    }
    // 如果没有找到字符c，返回NULL
    return (char *) NULL;
}

/**
 * 在字符串s中查找最后一个字符c的位置，并返回指向该字符的指针
 * @param s 字符串s
 * @param c 字符c
 * @return 指向字符c的指针，如果没有找到则返回NULL
 */
char *my_strrchr(const char *s, int c)
{
    // 设置最后一个匹配的位置为NULL
    char *last_match = NULL;
    // 遍历字符串s
    while (*s != '\0')
    {
        // 如果找到字符c
        if (*s == c)
        {
            // 记录匹配到的指针位置
            last_match = (char *) s;
        }
        ++s;
    }
    // 返回最后一次匹配的位置
    return last_match;
}

strstr

/**
 * 在字符串s中查找子字符串t，并返回指向该子字符串的指针
 * @param haystack 字符串s
 * @param needle 子字符串t
 * @return 指向子字符串t的指针
 */
char *my_strstr(const char *haystack, const char *needle)
{
    // 如果needle字符串为空，则返回haystack字符串
    if (*needle == '\0')
    {
        return (char *) haystack;
    }
    // 遍历haystack字符串
    while (*haystack != '\0')
    {
        // 遍历haystack和needle字符串，比较对应字符是否相等
        const char *h = haystack;
        const char *n = needle;
        while (*h == *n && *h != '\0')
        {
            ++h;
            ++n;
        }
        // 如果needle字符串已经遍历完，则返回haystack字符串
        if (*n == '\0')
        {
            return (char *) haystack;
        }

        // 遍历haystack字符串
        ++haystack;
    }
    // 如果没有找到子字符串，则返回NULL
    return NULL;
}

atoi

/**
 * 字符串nptr转整型
 * @param nptr 字符串
 * @return 字符串的整型
 */
int my_atoi(const char *nptr)
{
    // 初始化累加和为0
    int sum = 0;
    // 当指针指向的值不为空时，继续循环
    while (*nptr != '\0')
    {
        // 如果指针指向的值在0~9之间，则累加，并且指针后移
        if (*nptr >= '0' && *nptr <= '9')
        {
            sum = 10 * sum + (*nptr - '0');
            ++nptr;
        }
            // 否则跳出循环
        else
        {
            break;
        }
    }
    // 返回累加和
    return sum;
}