＜c语言学习＞简单的字符串函数，内存函数 模拟实现

字符串函数：

1.字符分类函数（例如isalpha、isdigit等）：这些函数通常用编于检查一个字符是否属于特定类别，如字母、数字等。模拟实现时，可以使用ASCII码或Unicode码进行判断。

        

int isalpha(char c) {
    if (('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z'))
        return 1;
    else
        return 0;
}

2.字符转换函数（例如toupper、tolower）：将字符转换为大写或小写。

char toupper(char c) {
    if ('a' <= c && c <= 'z')
        return c - 'a' + 'A';
    else
        return c; // 如果不是小写字母，则保持原样
}

3.strlen的使用和模拟实现：计算字符串长度，直到遇到结束符'\0'。

size_t strlen(const char *str) {
    size_t len = 0;
    while (str[len] != '\0')
        len++;
    return len;
}

4.strcpy的使用和模拟实现：复制一个字符串到另一个字符串缓冲区。

char *strcpy(char *dest, const char *src) {
    char *ptr = dest;
    while ((*ptr++ = *src++) != '\0');
    return dest;
}

5.strcat的使用和模拟实现：连接两个字符串。

char *strcat(char *dest, const char *src) {
    char *end = dest;
    while (*end != '\0')
        end++; // 移动到目标字符串的末尾
    while ((*end++ = *src++) != '\0'); // 拷贝源字符串并追加到目标字符串后
    return dest;
}

6.strcmp的使用和模拟实现：比较两个字符串是否相等，如果不等则返回字符差异的差值。

int strcmp(const char *s1, const char *s2) {
    while (*s1 && *s2 && (*s1 == *s2)) {
        s1++;
        s2++;
    }
    return (*(unsigned char *)s1 - *(unsigned char *)s2);
}

7.strncpy的使用：复制指定数量的字符从源字符串到目标字符串，并确保目标字符串以'\0'结束（如果空间足够的话）。

char *strncpy(char *dest, const char *src, size_t n) {
    char *d = dest;
    const char *s = src;
    while (n-- > 0 && (*d++ = *s++) != '\0') ;
    while (n-- > 0) *d++ = '\0'; // 填充剩余空间为'\0'
    return dest;
}

8.strncat的使用：类似于strcat，但是限制添加到目标字符串的字符数量。

char *strncat(char *dest, const char *src, size_t n) {
    char *end = dest;
    while (*end != '\0')
        end++;
    while (n-- > 0 && (*end++ = *src++) != '\0') ;
    *end = '\0'; // 确保目标字符串仍以'\0'结束
    return dest;
}

9.strncmp的使用：类似于strcmp，但只比较前n个字符。

int strncmp(const char *s1, const char *s2, size_t n) {
    while (n-- > 0 && *s1 && *s2 && (*s1 == *s2)) {
        s1++;
        s2++;
    }
    return (n < 0 || !*s1) ? 0 : (*(unsigned char *)s1 - *(unsigned char *)s2);
}

10.strstr的使用和模拟实现：查找子串在主串中的首次出现位置。

char *strstr(const char *haystack, const char *needle) {
    size_t needle_len = strlen(needle);
    for (; *haystack; haystack++) {
        if (memcmp(haystack, needle, needle_len) == 0)
            return (char *)haystack;
    }
    return NULL; // 如果找不到则返回NULL
}

11.strtok函数的使用：分解字符串成多个标记，用特定分隔符分隔。

char *strtok(char *str, const char *delim) {
    static char *last;
    if (str == NULL) str = last;
    str += strspn(str, delim); // 跳过分隔符
    if (*str == '\0') return NULL; // 如果没有更多标记则返回NULL
    last = str + strcspn(str, delim); // 找到下一个分隔符的位置
    if (*last) *last++ = '\0'; // 将分隔符替换为'\0'
    return str; // 返回当前标记
}

内存函数：

1.memcpy的使用和模拟实现：从源地址复制指定大小的字节到目标地址。

void *memcpy(void *dest, const void *src, size_t n) {
    unsigned char *d = (unsigned char *)dest;
    const unsigned char *s = (const unsigned char *)src;
    while (n--) *d++ = *s++;
    return dest;
}

2.memmove的使用：类似于memcpy，但在源和目标区域有重叠时也能正确处理。

void *memmove(void *dest, const void *src, size_t n) {
    unsigned char *d = (unsigned char *)dest;
    const unsigned char *s = (const unsigned char *)src;
    if (d < s) { // 如果目标在源之前，正常拷贝
        while (n--) *d++ = *s++;
    } else { // 如果目标在源之后或两者重叠，反向拷贝
        d += n - 1;
        s += n - 1;
        while (n--) *d-- = *s--;
    }
    return dest;
}

3.memset函数的使用：将一段内存区域填充为指定的字符。

void *memset(void *ptr, int value, size_t num) {
    unsigned char *p = (unsigned char *)ptr;
    while (num--) *p++ = (unsigned char)value;
    return ptr;
}

4.memcmp函数的使用：比较两个内存区域的内容，返回差异的第一个字节的差值。

int memcmp(const void *ptr1, const void *ptr2, size_t num) {
    const unsigned char *p1 = (const unsigned char *)ptr1;
    const unsigned char *p2 = (const unsigned char *)ptr2;
    while (num-- > 0 && *p1 == *p2) {
        p1++;
        p2++;
    }
    return num < 0 ? 0 : (*p1 - *p2);
}