字符函数和字符串函数

KrisZhang10

已于 2023-11-21 21:45:46 修改

阅读量285

点赞数 11

分类专栏： C语言高阶文章标签： c语言

于 2023-11-21 21:44:58 首次发布

本文链接：https://blog.csdn.net/m0_61630449/article/details/134541021

版权

C语言高阶专栏收录该内容

9 篇文章 0 订阅

订阅专栏

strerror（还有一个更直接的perror可以理解为printf + strerror）

函数介绍

strlen

size_t strlen ( const char * str );

字符串以‘\0’作为结束标志，strlen函数返回的是在字符串中‘\0’前面出现的字符个数（不包含'\0'）
参数指向的字符串必须要以 '\0' 结束。
注意函数的返回值为size_t，是无符号的(易错)

strcpy

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

Copies the C string pointed by source into the array pointed by destination, including the terminating null character (and stopping at that point).
源字符串必须以 '\0' 结束。
会将源字符串中的 '\0' 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。
学会模拟实现。

#include <stdio.h>
#include <assert.h>

char * my_strcpy(char *dest,const char *src)
{
    char *ret = dest;//提前保存好地址，否则，当后面复制完，指向的是\0的位置
    assert(dest && src);
    while(*dest++ = *src++)
    {
        ;
    }
}
int main()
{
    char arr1[] = "hehe";
    char arr2[20] = {0};
    my_strcpy(arr2,arr1);
    printf("%s\n",arr2);
    printf("%s\n",arr2);
    return 0;
}

strcat

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

Appends a copy of the source string to the destination string. The terminating null character in destination is overwritten by the first character of source, and a null-character is included at the end of the new string formed by the concatenation of both in destination.
源字符串必须以 '\0' 结束。目标空间也必须要有‘\0’
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。

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

char *my_strcat(char *dest,const char *str)
{
    assert(dest && str);
    char *ret = dest;
    while (*dest != '\0')
    {
        dest++;
    }
    //拷贝
    while (*dest++ = *str++)
    {
        ;
    }
    return ret;
}

int main()
{
    char arr1[20]="hello ";
    char arr2[]="world";
    //追加
    my_strcat(arr1,arr2);
    printf("%s\n",arr1);
    return 0;
}

strcmp

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

This function starts comparing the first character of each string. If they are equal to each other, it continues with the following pairs until the characters differ or until a terminating null-character is reached.
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字

int main()
{
    char*p = "abcdef";
    //比较2个字符串的内容的时候，不能使用==，应该使用strcmp
    if("abcdef"=="abcdef")//这里虽然能够编译成功，但是比较的是两个字符串首字符的地址，而并不是比较字符串的内容
    {
        
    }
    return 0;
}

#include <stdio.h>
#include <assert.h>

int my_strcmp(const char *str1,const char *str2)
{
    assert(str1 && str2);
    while (*str1++ == *str2++)
    {
        if(*str1 == '\0')
        {
            return 0;
        }
    }
    return *str1 - *str2;
//    if(*str1 > *str2)
//    {
//        return 1;
//    } else
//    {
//        return -1;
//    }
}
int main()
{
    char arr1[] = "abcdef";
    char arr2[] = "abq";
    int ret = my_strcmp(arr1,arr2);
    printf("%d\n",ret);
    return 0;
}

前面都属于长度不受限制的函数，因此总是会被告知不安全。所以引入了以下长度受限制的字符串函数。

strncpy

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

Copies the first num characters of source to destination. If the end of the source C string (which is signaled by a null-character) is found before num characters have been copied, destination is padded with zeros until a total of num characters have been written to it.
拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

strncat

strcat函数是不适合自己给自己追加的

strncat函数是可以自己给自己追加的

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

Appends the first num characters of source to destination, plus a terminating null-character.
If the length of the C string in source is less than num, only the content up to the terminating null-character is copied.

/* strncat example */
#include <stdio.h> 
#include <string.h>

int main () 
{
    char str1[20]; 
    char str2[20]; 
    strcpy (str1,"To be "); 
    strcpy (str2,"or not to be"); 
    strncat (str1, str2, 6); 
    puts (str1); 
    return 0;
}

strncmp

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

比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

strstr(朴素匹配算法)

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

Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1.

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

char *my_strstr(const char *str1,const char *str2)
{
    char *s1 = NULL;
    char *s2 = NULL;
    char *cp = (char *)str1;

    while (*cp)
    {
        s1 = cp;
        s2 = (char*)str2;
        while (*s1 && *s2 && *s1++ == *s2++)
        {
            ;
        }
        if(*s2 == '\0')
        {
            return cp;
        }
        cp++;
    }
    return NULL;
}

int main()
{
    char arr1[] = "abcdef";
    char arr2[] = "bcd";
    char *p = my_strstr(arr1,arr2);
    if(p == NULL)
    {
        printf("找不到\n");
    }
    else
    {
        printf("%s\n",p);
    }
    return 0;
}

strtok

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

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

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

int main()
{
    char arr[] = "abc@bbq.ggl";
    char copy[20] = {0};//最后会成这样abc\0bbq\0ggl\0
    strcpy(copy,arr);

    const char* p = "@.";
    char *str = strtok(copy,p);
    printf("%s\n",str);

    str = strtok(NULL,p);
    printf("%s\n",str);

    str = strtok(NULL,p);
    printf("%s\n",str);
    return 0;
}

但这样写代码并不灵活，每次有增加的分隔符都需要再追加print因此优化：

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

int main()
{
    char arr[] = "abc@bbq.ggl";
    char copy[20] = {0};//最后会成这样abc\0bbq\0ggl\0
    strcpy(copy,arr);

    const char* p = "@.";
    char *str = NULL;
    for (str = strtok(copy,p);str != NULL;str = strtok(NULL,p))
    {
        printf("%s\n",str);
    }
    return 0;
}

strerror（还有一个更直接的perror可以理解为printf + strerror）

char * strerror ( int errnum );

返回错误码，所对应的错误信息。

其实：

C语言的库函数在调用失败的时候，会将一个错误码存放在一个叫：errno的变量中，当我们想知道调用库函数的时候发生了什么错误信息，就可以将errno中的错误码翻译成错误信息。

/* strerror example : error list */ #include <stdio.h>
#include <string.h>
#include <errno.h>//必须包含的头文件
int main () 
{
    FILE * pFile;
    pFile = fopen ("unexist.ent","r"); 
    if (pFile == NULL)
        printf ("Error opening file unexist.ent: %s\n",strerror(errno));
        //errno: Last error number 
    return 0;
}
    Edit & Run

字符分类函数：

函数	如果他的参数符合下列条件就返回真
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	任何可打印字符，包括图形字符和空白字符

字符转换：

int tolower ( int c );

int toupper ( int c );

/* isupper example */ 
#include <stdio.h> 
#include <ctype.h> 
int main () 
{
    int i=0; 
    char str[]="Test String.\n"; 
    char c; 
    while (str[i]) 
    {
        c=str[I];
        if (isupper(c))
        c=tolower(c);
        putchar (c);
        i++;
    } 
    return 0;
}

前面的函数都是和字符串相关的

memcpy

void * memcpy ( void * destination, const void * source, size_t num );

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 '\0' 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。

void*-- 通用类型的指针，可以接受任意类型数据的地址

但是：这种指针不能直接解引用和+-运算！

这里打印出来是1 2 1 2 1 2 1 8 9 10

所以memcpy并不能满足该要求，引出memmove

//C语言中:memcpy拷贝不重叠的内存

//重叠的就交给memmove

//memmove > memcopy

memmove

void * memmove ( void * destination, const void * source, size_t num );

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

可以发现memmove和memcopy的函数声明很相似，但是需要考虑移动的条件，所以my_memmove要这样写：

/* memmove example */ 
#include <stdio.h> 
#include <string.h>

int main () 
{ 
    char str[] = "memmove can be very useful......"; 
    memmove (str+20,str+15,11); 
    puts (str); 
    return 0; 
}

memcmp

int memcmp ( const void * ptr1,const void * ptr2, size_t num)

比较从ptr1和ptr2指针开始的num个字节
返回值如下：

/* memcmp example */ 
#include <stdio.h> 
#include <string.h>

int main () 
{
    char buffer1[] = "DWgaOtP12df0"; 
    char buffer2[] = "DWGAOTP12DF0";    
    int n;
    n=memcmp ( buffer1, buffer2, sizeof(buffer1) );    
    if (n>0) printf ("'%s' is greater than '%s'.\n",buffer1,buffer2); 
    else if (n<0) printf ("'%s' is less than '%s'.\n",buffer1,buffer2); 
    else printf ("'%s' is the same as '%s'.\n",buffer1,buffer2);
    return 0;
}