字符函数和字符串函数（详解）

雪殇若兮_

已于 2023-04-06 13:38:28 修改

阅读量93

点赞数 2

分类专栏： C语言文章标签： c语言算法数据结构 Powered by 金山文档

于 2023-03-18 11:45:36 首次发布

本文链接：https://blog.csdn.net/weixin_53092099/article/details/129631691

版权

C语言专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1. 函数介绍

1.1 strlen

size_t strlen ( const char * str );

注意：

字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数。

注意函数的返回值为size_t，是无符号的（易错）。

#include <stdio.h>
int main()
{
const char*str1 = "abcdef";
const char*str2 = "bbb";
if(strlen(str2)-strlen(str1)>0)
{
printf("str2>str1\n");
}
else
{
printf("srt1>str2\n");
}
return 0;
}

1.2 strcpy

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

注意：

1.源字符串必须以 '\0' 结束。

2.会将源字符串中的 '\0' 拷贝到目标空间。

3.目标空间必须足够大，以确保能存放源字符串。

4.目标空间必须可变

#include <stdio.h>
#include<string.h>
int main()
{
    char arr1[] = "hehe";
    char arr2[20] = { 0 };
    //strcpy(arr2, arr1);
    //printf("%s\n", arr2);
    printf("%s\n", strcpy(arr2, arr1));
    return 0;
}

1.3 strcat

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

注意：

1.源字符串必须以 '\0' 结束。

2.目标空间必须有足够的大，能容纳下源字符串的内容。

3.目标空间必须可修改

4.实现追加

#include <stdio.h>
#include<string.h>
int main()
{

    char arr1[20] = "hello ";
    char arr2[] = "world";
    //追加
    strcat(arr1, arr2);
    printf("%s\n", arr1);
}

1.4 strcmp

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

标准规定：

第一个字符串大于第二个字符串，则返回大于0的数字

第一个字符串等于第二个字符串，则返回0

第一个字符串小于第二个字符串，则返回小于0的数字

#include <stdio.h>
#include<string.h>
int main()
{
    //char* p = "abcdef";
    比较2个字符串的内容的时候，不能使用==，应该使用strcmp
    //if ("abcdef" == "bbcdef")//这里比较的是连个字符串首字符的地址，而并不是字符串的内容
    char arr1[] = "abq";
    char arr2[] = "abq";
    int ret = strcmp(arr1, arr2);
    printf("%d\n", ret);
    return 0;
}

1.5 strncpy

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

注意：

1.拷贝num个字符从源字符串到目标空间。

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

#include <stdio.h>
#include<string.h>
int main()
{
    char arr1[] = "abcdef";
    char arr2[20] = "xxxxxxxxxxx";
    strncpy(arr2, arr1, 4);
    printf("%s\n", arr2);
    return 0;
}

1.6 strncat

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

追加num个字符从源字符串到目标空间。

#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;
}

1.7 strncmp

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

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

#include <stdio.h>
#include <string.h>
int main()
{
    char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
    int n;
    puts("Looking for R2 astromech droids...");
    for (n = 0; n < 3; n++)
        if (strncmp(str[n], "R2xx", 2) == 0)
        {
            printf("found %s\n", str[n]);
        }
    return 0;
}

1.8 strstr

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

在字符串str1中查找是否含有字符串str2，如果存在，返回str2在str1中第一次出现的地址；否则返回NULL。

#include <stdio.h>
#include <string.h>
int main()
{
    char str[] = "This is a simple string";
    char* pch;
    pch = strstr(str, "simple");
    strncpy(pch, "sample", 6);
    puts(str);
    return 0;
}

1.9 strtok

char *strtok(char *str, const char *delim)

参数

str—要被分解的字符串

delim—用作分隔符的字符（可以是一个，也可以是集合）

返回值

该函数返回被分解的第一个子字符串，若无可检索的字符串，则返回空指针

#include <string.h>
#include <stdio.h>
int main() {
    char str[80] = "aaa - bbb - ccc";
    const char s[2] = "-";   //字符串里可以是一个分隔符，也可以是分隔符的集合
    char* token;
    /* 获取第一个子字符串 */
    token = strtok(str, s);
    /* 继续获取其他的子字符串 */
    while (token != NULL) {
        printf("%s\n", token);
        token = strtok(NULL, s);
    }
    return 0;
}

1.第一次调用strtok()，传入的参数str是要被分割的字符串{aaa - bbb -ccc}，而成功后返回的是第一个子字符串{aaa}；

2.而第二次调用strtok的时候，传入的参数应该为NULL，使得该函数默认使用上一次未分割完的字符串继续分割，就从上一次分割的位置{aaa-}作为本次分割的起始位置，直到分割结束。

在这里我们可以看出strtok的基本使用方法：

1.strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串

中的位置。

2.strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标

记。

3.如果字符串中不存在更多的标记，则返回 NULL 指针

1.10 strerror

char * strerror ( int errnum );

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

#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;
}

1.11 memcpy

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

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。

这个函数在遇到 '\0' 的时候并不会停下来。

（如果source和destination有任何的重叠，复制的结果都是未定义的。）

#include <stdio.h>
#include <string.h>
struct {
    char name[40];
    int age;
} person, person_copy;
int main()
{
    char myname[] = "Pierre de Fermat";
    /* using memcpy to copy string: */
    memcpy(person.name, myname, strlen(myname) + 1);
    person.age = 46;
    /* using memcpy to copy structure: */
    memcpy(&person_copy, &person, sizeof(person));
    printf("person_copy: %s, %d \n", person_copy.name, person_copy.age);
    return 0;
}

1.12 memmove

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

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

如果源空间和目标空间出现重叠，就得使用memmove函数处理。

#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;
}

1.13 memcmp

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

比较从ptr1和ptr2指针开始的num个字节

返回值同strncmp

#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;
}

2. 库函数的模拟实现

2.1 模拟实现strlen

三种方式：

方式1：

//计数器方式
int my_strlen(const char * str)
{
int count = 0;
while(*str)
{
count++;
str++;
}
return count;
}

方式2：

//不能创建临时变量计数器
int my_strlen(const char * str)
{
if(*str == '\0')
return 0;
else
return 1+my_strlen(str+1);
}

方式3：

//指针-指针的方式
int my_strlen(char *s)
{
char *p = s;
while(*p != ‘\0’ )
p++;
return p-s;
}

2.2 模拟实现strcpy

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

2.3 模拟实现strcat

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;
}

2.4 模拟实现strstr

char * strstr (const char * str1, const char * str2)
{
char *cp = (char *) str1;
char *s1, *s2;
if ( !*str2 )
return((char *)str1);
while (*cp)
{
s1 = cp;
s2 = (char *) str2;
while ( *s1 && *s2 && !(*s1-*s2) )
s1++, s2++;
if (!*s2)
return(cp);
cp++;
}
return(NULL);

2.5 模拟实现strcmp

#include <assert.h>
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;
}

2.6 模拟实现memcpy

void* my_memcpy(void* dest, const void* src, size_t num)
{
    void* ret = dest;
    assert(dest && src);
    while (num--)
    {
        *(char*)dest = *(char*)src;
        dest = (char*)dest + 1;
        src = (char*)src + 1;
    }
    return ret;
}

2.7 模拟实现memmove

void* my_memmove(void* dest, const void* src, size_t num)
{
    void* ret = dest;
    assert(dest && src);
    if (dest < src)
    {
        //前->后
        while (num--)
        {
            *(char*)dest = *(char*)src;
            dest = (char*)dest + 1;
            src = (char*)src + 1;
        }
    }
    else
    {
        //后->前
        while (num--)
        {
            *((char*)dest + num) = *((char*)src + num);
        }
    }
    return ret;
}