字符函数与字符串函数

1.字符函数    

          所有的字符函数，头文件 均为 <ctype.h>

（1）字符分类函数   

函数	判断   符合以下条件，返回真
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	字母或者数字 a~z，A~Z， 0~9
ispunct	标点符号，任何 不属于数组或者字母 且 可打印的 图形符号
isgraph	任何图形字符
isprint	任何可打印字符，包含图形字符和空白字符

(2) 字符转换函数

int tolower(int c); // 将参数传进去的小写字母转大写
int toupper(int c); // 将参数传进去的大写字母转小写

示例：

#include <stdio.h>
#include <stype.h>

int main()
{
    int i = 0;
    char str[] = "Test String.\n";
    char c;
    while(str[i)
    {
        c = str[i];
    if(islower(c))
        c = toupper(c);
    putchar(c);
    i++;
    }
    return 0;
}

2. 部分常见的字符串函数

（1）strlen : 计算字符串中字符个数

size_t strlen (const char* str);

strlen函数返回的是字符串中 ' \0 ' 前面出现的字符个数；   

字符串以 ' \0 '作为结束标志；

 << strlen 模拟实现

// 方法 1 逐个计数
int copy_strlen(const char* str)
{
    int count = 0;
    assert(str);
    while(*str)
    {
        count++;
        str++;
    }
    return count;
}


//方法 2 函数递归
int copy_strlen(const char* str)
{
    assert(str);
    if(*str == '\0')
        return 0;
    else
        return 1 + copy_strlen(str+ 1);
}

//方法 3 指针-指针
int copy_strlen(char* s)
{
     assert(str);
     char* p = s;
     while(*p != '\0')
     {
         p++;
     }
     return p-s;
}

(2) strcpy / strncpy ： 拷贝字符串至目标空间

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

同 : 源字符串必须以'\0'结束，且会将'\0'拷贝到目标空间；

       目标空间必须足够大（确保能够存放源字符串），且 目标空间必须可变

异：strncpy ： 拷贝num个字符从源字符串到目标空间；

                   如果源字符串的长度小于num,则拷贝完源字符串之后，在目标后面追加0，直到num个

<< strcpy 模拟实现

char* copy_strcpy(char* dest, const char* src)
{
    char* ret = dest;
    assert(dest && src);

    while((*dest++ = *src++))
    {
        ;
    }
    return ret;
}

<< strncpy 模拟实现

char* my_strncpy(char* dest, const char* src, size_t n) 
{
    size_t i;
    for (i = 0; i < n && src[i] != '\0'; i++) 
    {
        dest[i] = src[i];
    }
    for (; i < n; i++) 
    {
        dest[i] = '\0';
    }
    return dest;
}

（3）strcat / strncat : 追加字符串

char* strcat(char* dest, const char* src);
char* strncat(char* dest, const char* src, size_t num);

同 : 源字符串和目标字符串都必须以'\0'结尾；

       目标空间必须足够大 且 目标空间必须可以修改；

异 : strncat :如果source中的string长度小于num，则只复制到结束空字符之前的内容；

<< strcat 模拟实现

char* copy_strcat(char* dest, const char* src)
{
    char* ret = dest;
    assert(dest && src);
    while(*dest)
    {
        dest++;
    }
    while((*dest++ = *src++))
    {
        ;
    }
    return ret;
}

<< strncat 模拟实现

char* copy_strncat(char* str1, const char* str2, size_t num)
{
	assert(str1 && str2);
	char* ret = str1;
	str1 += strlen(str1);

	while (num--)
	{
		*str1++ = *str2++;
	}
	*str1 = '\0';

	return ret;
}

（3) strcmp / strncmp : 按照字典顺序 / 两个字符串对应位置上字符ASCII码值大小 比较 字符串大小

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

同 ： str1 > str2 ，返回大于0的数字；

         str1 = str2 ,    返回0；

          str1 < str2 ， 返回小于0的数字；

<< strcmp 模拟实现

int copy_strcmp(const char* str1, const char* str2)
{
    int ret = 0;
    assert(src && dest);
    while(*str1 == *str2)
    {
        if(*str1 == *str2)
            retrun 0;
        str1++;
        str2++;
    }
    return *str1-*str2;
}

<< strncmp 模拟实现

int my_strncmp(const char* str1, const char* str2, size_t n) 
{
    size_t i;
    for (i = 0; i < n && str1[i] != '\0' && str2[i] != '\0'; i++) 
    {
        if (str1[i] != str2[i]) 
        {
            return (unsigned char)str1[i] - (unsigned char)str2[i];
        }
    }
    if (i < n) 
    {
        return (unsigned char)str1[i] - (unsigned char)str2[i];
    }
    return 0;
}

（4) strstr : 查找子字符串

char* strstr(const char*,const char*)

  strstr 的使用

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

int main()
{
    char str[] = "this is a somple string";
    char* pch;
    pch = strstr(pch,"simple");
    printf("%s\n",str);
    return 0;
}

 << strstr 模拟实现

char* copy_strstr(const char* str1, const char* str2)
{
    char* ret = (char*)str1;
    char *s1, *s2;

    if (!*str2)
        return((char*)str1);

    while (*ret)
    {
        s1 = ret;
        s2 = (char*)str2;

        while (*s1 && *s2 && !(*s1 - *s2))
        {
            s1++;
            s2++;
        }

        if (!*s2)
            return ret;

        ret++;
    }
    return(NULL);
}