工学1号馆

home

C标准库string.h实现

By Wu Yudong on September 23, 2015

本文主要介绍C标准库<string.h>实现

本文地址:http://wuyudong.com/archives/950,转载请注明源地址。

1.背景知识

<string.h>中声明的函数是对标准C的一个重要补充,它们支持C语言把文本作为字符数组操作的传统。

string.h是C语言中C标准库的头文件,其中包含了宏定义、常量以及函数和类型的声明,涉及的内容除了字符串处理之外,还包括大量的内存处理函数;因此,string.h这个命名是不恰当的。在string.h中定义的函数十分常用,作为C标准库的一部分,它们被强制要求可以在任何支持C语言的平台上运行。但是,部分函数存在一些安全隐患,例如缓存溢出等,导致程序员宁愿使用一些更安全的函数而放弃一定的可移植性。同时,这些字符串函数只能处理ASCII字符集或兼容ASCII的字符集,如ISO-8859-1;在处理存在多字节字符的字符集,如UTF-8时,会产生一个警告,指出对字符串“长度”的计算是以字节而不是以Unicode字符为单位。非ASCII兼容字符集的字符串处理函数一般位于wchar.h中。

C标准库提供了所有重要的功能。这些函数可以对一下3种形式的串进行操作:

  • 名字以mem开头的函数对任意的字符序列进行操作
  • 名字以strn开头的函数对非空字符序列进行操作
  • 所有其他名字以str开头的函数对空字符结尾的字符序列进行操作

2.<string.h>的内容

常量和类型

名称 说明
NULL 表示空指针常量的宏,即表示一个不指向任何有效内存单元地址的指针常量。
size_t 无符号整型,被用于sizeof运算符的返回值类型。

代码如下:

#ifndef _STRING_H
#define _STRING_H
#define NULL    ((void *)0)
#ifndef _SIZE_T
#define _SIZE_T
typedef unsigned int size_t;    /* type returned by sizeof */
#endif /*_SIZE_T */

函数

名称 说明
void *memcpy(void *dest, const void *src, size_t n); 将n字节长的内容从一个内存地址复制到另一个地址;如果两个地址存在重叠,则最终行为未定义
void *memmove(void *dest, const void *src, size_t n); 将n字节长的内容从一个内存地址复制到另一个地址;与memcpy不同的是它可以正确作用于两个存在重叠的地址
void *memchr(const void *s, char c, size_t n); 在从s开始的n个字节内查找c第一次出现的地址并返回,若未找到则返回NULL
int memcmp(const void *s1, const void *s2, size_t n); 对从两个内存地址开始的n个字符进行比较
void *memset(void *, int, size_t); 用某种字节内容覆写一段内存空间
char *strcat(char *dest, const char *src); 在字符串dest之后连接上src
char *strncat(char *dest, const char *src, size_t n); 在字符串dest之后连接上src,最多增加n个字符
char *strchr(const char *, int); 从字符串头开始查找某字符出现的位置
char *strrchr(const char *, int); 从字符串尾开始查找某字符出现的位置
int strcmp(const char *, const char *); 基于字典顺序比较两个字符串
int strncmp(const char *, const char *, size_t); 基于字典顺序比较两个字符串,最多比较n个字节
int strcoll(const char *, const char *); 基于当前区域设置的字符顺序比较两个字符串
char *strcpy(char *toHere, const char *fromHere); 将一个字符串从一个位置复制到另一个位置
char *strncpy(char *toHere, const char *fromHere, size_t); 将一个字符串从一个位置复制到另一个位置,最多复制n个字节
char *strerror(int); 返回错误码对应的解释字符串,参见errno.h(非线程安全函数)
size_t strlen(const char *); 返回一个字符串的长度
size_t strspn(const char *s, const char *strCharSet); 从字符串s的起始处开始,寻找第一个出现在strCharSet中的字符,返回其位置索引值
size_t strcspn(const char *s, const char *strCharSet); 从字符串s的起始处开始,寻找第一个出现在strCharSet中的字符,返回其位置索引值
char *strpbrk(const char *s, const char *strCharSet); 在字符串s中查找strCharSet中任意字符第一次出现的位置的指针值
char *strstr(const char *haystack, const char *needle); 在字符串haystack中查找字符串needle第一次出现的位置,heystack的长度必须长于needle
char *strtok(char *, const char *); 将一个字符串分隔成一系列字符串;此函数非线程安全,且不可重入
size_t strxfrm(char *dest, const char *src, size_t n); 根据当前locale转换一个字符串为strcmp使用的内部格式

函数原型代码如下:

void *memchr(const void *_s, int _c, size_t _n);
int memcmp(const void *_s1, const void *_s2, size_t _n);
void *memcpy(void *_s1, const void *_s2, size_t _n);
void *memmove(void *_s1, const void *_s2, size_t _n);
void *memset(void *_s, int _c, size_t _n);
char *strcat(char *_s1, const char *_s2);
char *strchr(const char *_s, int _c);
int strncmp(const char *_s1, const char *_s2, size_t _n);
int strcmp(const char *_s1, const char *_s2);
int strcoll(const char *_s1, const char *_s2);
char *strcpy(char *_s1, const char *_s2);
size_t strcspn(const char *_s1, const char *_s2);
char *strerror(int _errnum);
size_t strlen(const char *_s);
char *strncat(char *_s1, const char *_s2, size_t _n);
char *strncpy(char *_s1, const char *_s2, size_t _n);
char *strpbrk(const char *_s1, const char *_s2);
char *strrchr(const char *_s, int _c);
size_t strspn(const char *_s1, const char *_s2);
char *strstr(const char *_s1, const char *_s2);
char *strtok(char *_s1, const char *_s2);
size_t strxfrm(char *_s1, const char *_s2, size_t _n);

3.<string.h>的实现

1、void *memcpy(void *dest, const void *src, size_t n);
功能:从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中
返回:函数返回指向dest的指针

void * memcpy(void *s1, const void *s2, register size_t n)
{
    register char *p1 = s1;
    register const char *p2 = s2;


    if (n) {
        n++;
        while (--n > 0) {
            *p1++ = *p2++;
        }
    }
    return s1;
}

2、void *memmove( void* dest, const void* src, size_t count );

功能:由src所指内存区域复制count个字节到dest所指内存区域

返回:函数返回指向dest的指针

void * memmove(void *s1, const void *s2, register size_t n)
{
    register char *p1 = s1;
    register const char *p2 = s2;
    if (n>0) {
        if (p2 <= p1 && p2 + n > p1) {
            /* overlap, copy backwards */
            p1 += n;
            p2 += n;
            n++;
            while (--n > 0) {
                *--p1 = *--p2;
            }
        } else {
            n++;
            while (--n > 0) {
                *p1++ = *p2++;
            }
        }
    }
    return s1;
}

3、void *memchr(const void *buf, int ch, size_t count);

功能:从buf所指内存区域的前count个字节查找字符ch
返回:当第一次遇到字符ch时停止查找。如果成功,返回指向字符ch的指针;否则返回NULL
void *memchr(const void *s, register int c, register size_t n)
{
    register const unsigned char *s1 = s;
    c = (unsigned char) c;
    if (n) {
        n++;
        while (--n > 0) {
            if (*s1++ != c) continue;
            return (void *) --s1;
        }
    }
    return NULL;
}

4、int memcmp(const void *buf1, const void *buf2, unsigned int count);

功能:比较内存区域buf1和buf2的前count个字节
返回:

当buf1<buf2时,返回值<0
当buf1=buf2时,返回值=0
当buf1>buf2时,返回值>0
int memcmp(const void *s1, const void *s2, size_t n)
{
    register const unsigned char *p1 = s1, *p2 = s2;
    if (n) {
        n++;
        while (--n > 0) {
            if (*p1++ == *p2++) continue;
            return *--p1 - *--p2;
        }
    }
    return 0;
}

5、void *memset(void *s, int ch, size_t n);

功能:将s中前n个字节用 ch 替换并返回 s 在一段内存块中填充某个给定的值,它是对较大的结构体或数组进行清零操作的一种最快方法
返回:指向s的指针
void *memset(void *s, register int c, register size_t n)
{
    register char *s1 = s;

    if (n>0) {
        n++;
        while (--n > 0) {
            *s1++ = c;
        }
    }
    return s;
}

6、char *strcat(char *dest,char *src);

功能:把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')并添加'\0'。

char *strcat(char *ret, register const char *s2)
{
    register char *s1 = ret;
    while (*s1++ != '\0')
        /* EMPTY */ ;
    s1--;
    while (*s1++ = *s2++)
        /* EMPTY */ ;
    return ret;
}

7、char *strncat(char * s1,const char * s2.size_t n);

功能:把src所指字符串的前n个字符添加接功能到dest结尾处(覆盖dest结尾处接功能的'\0')并添加'\0'。
char *strncat(char *ret, register const char *s2, size_t n)
{
    register char *s1 = ret;

    if (n > 0) {
        while (*s1++)
            /* EMPTY */ ;
        s1--;
        while (*s1++ = *s2++)  {
            if (--n > 0) continue;
            *s1 = '\0';
            break;
        }
        return ret;
    } else return s1;
}

8、char *strchr(const char *s,char c);

功能:查找字符串s中首次出现字符c的位置

char *strchr(register const char *s, register int c)
{
    c = (char) c;

    while (c != *s) {
        if (*s++ == '\0') return NULL;
    }
    return (char *)s;
}

9、char *strrchr(const char *s, int c)

功能:查找一个字符c在另一个字符串str中末次出现的位置(也就是从str的右侧开始查找字符c首次出现的位置),并返回从字符串中的这个位置起,一直到字符串结束的所有字符。如果未能找到指定字符,那么函数将返回NULL。
char *strrchr(register const char *s, int c)
{
    register const char *result = NULL;

    c = (char) c;

    do {
        if (c == *s)
            result = s;
    } while (*s++ != '\0');

    return (char *)result;
}

10、int strcmp(const char *s1,const char * s2);

功能:比较两个字符串。设这两个字符串为str1,str2,若str1=str2,则返回零;若str1>str2,则返回正数;若str1<str2,则返回负数。

int strcmp(register const char *s1, register const char *s2)
{
    while (*s1 == *s2++) {
        if (*s1++ == '\0') {
            return 0;
        }
    }
    if (*s1 == '\0') return -1;
    if (*--s2 == '\0') return 1;
    return (unsigned char) *s1 - (unsigned char) *s2;
}

11、int strncmp(char *str1, char *str2, int maxlen);

功能:这个函数用来比较s1和s2字符串,这个函数将返回一个值, 它的符号与第一对不同的字符的比较结果相关。 如果两个字符串相等的话,strncmp将返回0。 如果s1是s2的一个子串的话,s1小于s2。此函数与strcmp极为类似。不同之处是,strncmp函数是指定比较size个字符。也就是说,如果字符串s1与s2的前size个字符相同,函数返回值为0。
int strncmp(register const char *s1, register const char *s2, register size_t n)
{
    if (n) {
        do {
            if (*s1 != *s2++)
                break;
            if (*s1++ == '\0')
                return 0;
        } while (--n > 0);
        if (n > 0) {
            if (*s1 == '\0') return -1;
            if (*--s2 == '\0') return 1;
            return (unsigned char) *s1 - (unsigned char) *s2;
        }
    }
    return 0;
}

12、int strcoll(const char *s1,const char * s2);

功能:根据LC_COLLATE比较字符串s1和s2

int strcoll(register const char *s1, register const char *s2)
{
    while (*s1 == *s2++) {
        if (*s1++ == '\0') {
            return 0;
        }
    }
    return *s1 - *--s2;
}

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

功能:把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间

说明:src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。返回指向dest的指针。

char *strcpy(char *ret, register const char *s2)
{
    register char *s1 = ret;

    while (*s1++ = *s2++)
        /* EMPTY */ ;

    return ret;
}

14、char *strncpy(char *_s1, const char *_s2, size_t _n);

功能:(c/c++)复制字符串src中的内容(字符,数字、汉字....)到字符串dest中,复制多少由size_t的值决定,返回指向dest的指针。如果遇到空字符('\0'),则空字符后面全部为空(字符)

char *strncpy(char *ret, register const char *s2, register size_t n)
{
    register char *s1 = ret;

    if (n>0) {
        while((*s1++ = *s2++) && --n > 0)
            /* EMPTY */ ;
        if ((*--s2 == '\0') && --n > 0) {
            do {
                *s1++ = '\0';
            } while(--n > 0);
        }
    }
    return ret;
}

15、char *strerror(int errnum)

功能:通过标准错误的标号,获得错误的描述字符串。

char *strerror(register int errnum)
{
    extern const char *_sys_errlist[];
    extern const int _sys_nerr;

      if (errnum < 0 || errnum >= _sys_nerr)
        return "unknown error";
    return (char *)_sys_errlist[errnum];
}

16、size_t strlen(const char *org)

功能:计算字符串s的(unsigned int型)长度,不包括'\0'在内
说明:返回s的长度,不包括结束符NULL
size_t strlen(const char *org)
{
    register const char *s = org;

    while (*s++)
        /* EMPTY */ ;

    return --s - org;
}

17、size_t strspn (const char *s,const char * accept);

功能:strspn()从参数s 字符串的开头计算连续的字符,而这些字符都完全是accept 所指字符串中的字符。简单的说,若strspn()返回的数值为n,则代表字符串s 开头连续有n 个字符都是属于字符串accept内的字符

size_t strspn(const char *string, const char *in)
{
    register const char *s1, *s2;

    for (s1 = string; *s1; s1++) {
        for (s2 = in; *s2 && *s2 != *s1; s2++)
            /* EMPTY */ ;
        if (*s2 == '\0')
            break;
    }
    return s1 - string;
}

18、size_t strcspn(const char *string, const char *notin)

功能:顺序在字符串s1中搜寻与s2中字符的第一个相同字符,返回这个字符在S1中第一次出现的位置

size_t strcspn(const char *string, const char *notin)
{
    register const char *s1, *s2;

    for (s1 = string; *s1; s1++) {
        for(s2 = notin; *s2 != *s1 && *s2; s2++)
            /* EMPTY */ ;
        if (*s2)
            break;
    }
    return s1 - string;
}

19、char *strpbrk(const char *s1, const char *s2);

功能:依次检验字符串s1中的字符,当被检验字符在字符串s2中也包含时,则停止检验,并返回该字符位置,空字符NULL不包括在内

char *strpbrk(register const char *string, register const char *brk)
{
    register const char *s1;

    while (*string) {
        for (s1 = brk; *s1 && *s1 != *string; s1++)
            /* EMPTY */ ;
        if (*s1)
            return (char *)string;
        string++;
    }
    return (char *)NULL;
}

20、char *strstr(const char *str1, const char *str2);

功能:返回str2第一次在str1中的位置,如果没有找到,返回NULL
char *strstr(register const char *s, register const char *wanted)
{
    register const size_t len = strlen(wanted);

    if (len == 0) return (char *)s;
    while (*s != *wanted || strncmp(s, wanted, len))
        if (*s++ == '\0')
            return (char *)NULL;
    return (char *)s;
}

21、char *strtok(char *string, const char *separators)

功能:分解字符串为一组字符串。s为要分解的字符串,delim为分隔符字符串。

char *strtok(register char *string, const char *separators)
{
    register char *s1, *s2;
    static char *savestring;

    if (string == NULL) {
        string = savestring;
        if (string == NULL) return (char *)NULL;
    }

    s1 = string + strspn(string, separators);
    if (*s1 == '\0') {
        savestring = NULL;
        return (char *)NULL;
    }

    s2 = strpbrk(s1, separators);
    if (s2 != NULL)
        *s2++ = '\0';
    savestring = s2;
    return s1;
}

22、size_t strxfrm(char *s1, const char *save, size_t n)

功能:根据num长度拷贝前num个字符到目的字符串中,并返回源字符串长度。同时,该函数还可以自作为返回字符串长度,这时num=0,destination允许传入NULL

size_t strxfrm(register char *s1, register const char *save, register size_t n)
{
    register const char *s2 = save;

    while (*s2) {
        if (n > 1) {
            n--;
            *s1++ = *s2++;
        } else
            s2++;
    }
    if (n > 0)
        *s1++ = '\0';
    return s2 - save;
}

如果文章对您有帮助,欢迎点击下方按钮打赏作者

Comments

No comments yet.
To verify that you are human, please fill in "七"(required)