【C语言】字符与字符串函数及模拟实现

strlen( )函数

size_t strlen ( const char * str );

求字符串长度

• 字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
• 参数指向的字符串必须要以 ‘\0’ 结束。
• 注意函数的返回值为size_t，是无符号的（ 易错 ）
• 模拟实现
  • 方式 1：计数器

void* memmove(void* dst, const void* src, int count)
{
	void* ret = dst;
	if (dst <= src || (char*)dst >= ((char*)src + count)) {
		while (count--) {
			*(char*)dst = *(char*)src;
			dst = (char*)dst + 1;
			src = (char*)src + 1;
		}
	}
	else {
		dst = (char*)dst + count - 1;
		src = (char*)src + count - 1;
		while (count--) {
			*(char*)dst = *(char*)src;
			dst = (char*)dst - 1;
			src = (char*)src - 1;
		}
	}
	return(ret);
}

• 方式 2：递归(不创建临时变量)

    int my_strlen(const char* str)
    {    
        if(*str) return 1 + my_strlen(str + 1);
        else return 0;
    }

• 方式 3：双指针

    int my_strlen(const char* str)
    {    
        char *p = s; 
        while(*p != ‘\0’ ) 
        p++; 
        return p-s;
    }

strcpy( )函数

char* strcpy(char * destination, const char * source );

字符串拷贝

• 源字符串必须以 ‘\0’ 结束
• 会将源字符串中的 ‘\0’ 拷贝到目标空间
• 目标空间必须足够大，以确保能存放源字符串
• 目标空间必须可变
• 模拟实现

  char* my_strcpy(char* dest, const char* src)
  {
      char* ret = dest;
      assert(dest && src);
      while(*dest++ = *src++) ;
      /*while(*src)   优化前
      {
          *dest = *src;
          dest++;
          src++;
      }
      *src = *dest;
      */
      return ret;
  }
  

strcat( )函数

char * strcat ( char * destination, const char * source );

字符串追加

• 源字符串必须以 ‘\0’ 结束
• 会将源字符串中的 ‘\0’ 拷贝到目标空间
• 目标空间必须足够大，以确保能存放源字符串
• 目标空间必须可变
• 模拟实现

char *my_strcat(char *dest, const char*src) 
{ 
    char *ret = dest; 
    assert(dest != NULL); 
    assert(src != NULL); 
    while(*dest) 
    { 
    dest++; 
    } 
    while((*dest++ = *src++)) 
    { 
    ; 
    } 
    return ret; 
}

strcmp( )函数

字符串比较

int strcmp ( const char* str1, const char* str2 );

• 标准规定：
  • 第一个字符串大于第二个字符串，则返回大于0的数字
  • 第一个字符串等于第二个字符串，则返回0
  • 第一个字符串小于第二个字符串，则返回小于0的数字

注意： 不同编译器的函数返回都符合标准规定，返回 1、0或-1，仅仅是 vs 出现的特定情况

• 模拟实现

int *my_strcmp(const char* str1, const char* str2 );
{ 
    assert(str1 && str2); 
    while(*str1 == *str2) 
    { 
        if(*str1 == '\0')
            return 0;
        str1++;
        str2++;
    } 
    return *str1 - *str2;
    /*
    if(*str1 > *str2)
        return 1;
    else 
        return -1;
    */
    return ret; 
}

strncpy( )函数

char * strncpy ( char * destination, const char * source, size_t num);

长度受限的字符串拷贝

• 拷贝num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个
• 模拟实现

  char* my_strcpy(char* dest, const char* str)
  {
      char* ret = dest;
      assert(dest && src);
      while(*dest++ = *str++) ;
      /*while(*str)   优化前
      {
          *dest = *str;
          dest++;
          str++;
      }
      *str = *dest;
      */
  }
  

strncat( )函数

char * strncat ( char * destination, const char * source, size_t num );

长度受限的字符串追加

• 将num个字符从源字符串到目标空间，再加上一个中止字符’\0’。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，就停止追加

strncmp( )函数

长度受限的字符串比较

int strncmp ( const char * str1, const char * str2, size_t num );

• 标准规定：
  • 第一个字符串大于第二个字符串，则返回大于0的数字
  • 第一个字符串等于第二个字符串，则返回0
  • 第一个字符串小于第二个字符串，则返回小于0的数字

注意： 不同编译器的函数返回都符合标准规定，返回 1、0或-1，仅仅是 vs 出现的特定情况

• 模拟实现

int *my_strcmp(const char* str1, const char* str2 ); 
{ 
    assert(str1 && str2); 
    while(*str1 == *str2) 
    { 
        if(*str1 == '\0')
            return 0;
        str1++;
        str2++
    } 
    return *str1 - *str2;
    /*
    if(*str1 > *str2)
        return 1;
    else 
        return -1;
    */
    return ret; 
}

strstr( )函数

char* strstr ( const char* str, const char* substr);

找子串函数

• 返回指向 str1 中第一次出现 str2 的指针，如果 str2 不是 str1 的一部分，则返回空指针。
• 模拟实现
  • 方法一：朴素遍历

char* my_strstr(const char* str, const char* substr)
{
    assert(str && substr);
    if(*substr == '\0')
        return (char*)str;

    const char* p1 = str;
    const char* p2 = substr;
    const char* cur = str;
    while(*cur)
    {
        p1 = cur;
        p2 = substr;
        while(*p1 == *p2 && *p1 && *p2)
        {
            p1++;
            p2++;   
        }
        if(*p2 == '\0')
            return (char*)cur;
        cur++;
    }
    return NULL;
}

• 方法2：KMP算法

strtok( )函数

char * strtok ( char * str, const char * sep );

• 参数介绍：
  • sep是个字符串，定义了用作分隔符的字符集合
  • str是被分割的字符串，包含了0个或者多个由sep字符串中一个或者多个被分隔符分割的标记(被分的部分)。
• 函数功能：
  • strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
  • strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
  • strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
  • 如果字符串中不存在更多的标记，则返回 NULL 指针。
• 有趣的实际应用：

#include <stdio.h>
#include <string.h>
int main()
{
    char* p = "111.222&333^&4444";
    const char* sep = ".&^";
    char arr[30];
    char* temp = NULL;
    strcpy(arr, p);//将数据拷贝一份，供strtok( )修改
    for (temp = strtok(arr, sep); temp != NULL; temp = strtok(NULL, sep))
    {
        printf("%s\n", temp);
    }
}

strerror( )函数

char * strerror ( int errnum );

• 参数为错误码，返回值为对应的错误信息字符串
• 函数参数通常使用 <errno.h> 中的errno，errno是一个全局变量，自动被赋值为当前错误的错误码。

字符函数

• 字符分类函数

函数	判断条件 符合下列条件就返回真
iscntrl	任何控制字符
isspace	空白字符：空格‘ ’，换页‘\f’，换行’\n’，回车‘\r’，制表符’\t’或者垂直制表符’\v
isdigit	十进制数字 0~9
isxdigit	十六进制数字，包括所有十进制数字，小写字母a-f，大写字母A-F
islower	小写字母a-z
isupper	大写字母A-Z
isalpha	字母a-z或A-Z
isalnum	字母或者数字
ispunct	标点符号，任何不属于数字或字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符、

• 字符转换函数

int tolower(int c); 	//大写转小写
int toupper(int c);		//小写转大写