c语言——字符串函数和内存操作函数

简介: c语言——字符串函数和内存操作函数

一、求字符串长度函数(strlen)

包含在<string.h>头文件里


功能:返回字符串中有效字符的个数,遇到‘\0’结束,不包括结束符‘\0’.


函数的参数为------const char* str:字符指针

返回值的类型------size_t:无符号整数(即:unsigned int)

模拟实现strlen:

方法一:计数器的方法

#include <stdio.h>
int my_strlen(char* p)
{
    int n= 0;
    while (*p++ != '\0')
    {
        n++;
    }
    return n;
}
int main()
{
    char arr[10] = "abcdefghi";
    int num = my_strlen(arr);//统计字符串的个数
    printf("%d\n", num);
    return 0;
}

方法二:不能创建临时变量的计数器

#include <stdio.h>
int my_strlen(char* p)
{
    if (*p == '\0')
        return 0;
    return 1 + my_strlen(++p);//p的地址加1,然后传递过去
}
int main()
{
    char arr[10] = "abcdefghi";
    int num = my_strlen(arr);
    printf("%d\n", num);
    return 0;
}

方法三:用指针-指针的方法

#include <stdio.h>
int my_strlen(char* p)
{
    char* p1 = p;
    while (*p1 != '\0')
        p1++;
    return p1 - p;//指向同个数组的两个指针相减,得到的数为 指针之间的元素个数
}
int main()
{
    char arr[10] = "abcdefghi";
    int num = my_strlen(arr);
    printf("%d\n", num);
    return 0;
}

二、长度不受限制的字符串函数

包含在<string.h>头文件里


2.1字符串拷贝函数(strcpy)

功能:

源字符串必须以‘\0’结束。

会将源字符串里的‘\0’拷贝到目标空间。

目标空间足够大,以确保存放源字符串。

目标空间必须可变


1.函数的参数:

char* destination---------目标字符串的首地址

const char* source------源地址:被复制的字符串的首地址,用const

饰,避免修改掉被拷贝的字符串

2.函数的返回值类型:char*:返回的是目标字符串的首地址

模拟实现strcpy:

#include <stdio.h>
char* my_strcpy(char* p,  char* p1)//char*类型为了实现链式访问
{
    char* dest = p;
    while (*p1 != '\0')
    {
        *p = *p1;
        p++;
        p1++;
    }
    *p=*p1;
    return dest;
}
int main()
{
    char arr1[20] = { '1','2','3','4','5','6','7','8','9','a','b','c','d'};
    char arr2[] = "hello math";
    my_strcpy(arr1, arr2);
    printf("%s\n", arr1);
    return 0;
}

2.2字符串连接函数(strcat)

功能:

连接两个字符数组中的字符串,将源字符串的内容连接到目标空间中字符串后面,结果放到目标空间中。(源字符串和目标空间中要有‘\0’)

不能自己给自己追加

模拟实现strcat:

#include <stdio.h>
char* my_strcat(char* dest, const char* sour)//为了实现链式访问
{
    char* ret = dest;//ret指向目标空间首地址
    while (*dest != '\0')//找到目标空间的’\0‘
    {
        dest++;
    }
    while (*sour != '\0')//源字符串不等于’\0‘就一直循环
    {
        *dest = *sour;//把源字符串的内容连接到目标空间
        dest++;
        sour++;
    }
    *dest = *sour;
    return ret;
}
int main()
{
    char arr1[20] = "1234567";
    char arr2[] = "hello math";
    my_strcat(arr1, arr2);
    printf("%s\n", arr1);
    return 0;
}

2.3字符串比较函数(strcmp)

功能:

比较str1和str2.

  1. str1大于str2,函数返回值为1
  2. str小于str2,函数返回值为-1
  3. str等于str2,函数返回值为0

模拟实现strcmp:

#include <stdio.h>
int my_strcmp(const char* str1, const char* str2)//返回1个整型
{
    while (*str1 == *str2)//字符串1和字符串2相等就循环
    {
        if (*str1 == '\0')
            return 0;
        str1++;
        str2++;
 }
    if (*str1 > *str2)
        return 1;
    else
        return -1;
}
int main()
{
    char arr1[20] = "hello pan";
    char arr2[] = "hello math";
    int n=my_strcmp(arr1, arr2);
    printf("%d\n", n);
    return 0;
}

三、长度受限制的字符串函数

3.1strncpy

源字符串的num个字符拷贝到目标空间


功能:把src所指由NULL结束的字符串的前n个字节复制到dest所指的数组中。

说明:如果src的前n个字节不含NULL字符,则结果不会以NULL字符结束。

如果src的长度小于n个字节,则以NULL填充dest直到复制完n个字节。

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

返回指向dest的指针 。

#include <stdio.h>
#include <assert.h>
char* strncpy_(char* p1, char* p2, int x)
{
    assert(p1);//断言目标空间不能为空
    assert(p2);
    char* dest = p1;
    while (x--&&*p2)//p2拷贝到'\0'或拷贝结束
    {
        *dest=*p2;
        dest++;
        p2++;
    }
    if (!*p2)//p2拷贝完了为真
    {
        while (x--)//对多的数进行拷贝
        {
            *dest = '\0';
            dest++;
         }
    }
    return p1;
}
void text_1()
{
    char arr1[] = "abcdef";
    char arr2[10] = { 1,2,3,4,5,6,7,8,9,0 };
    strncpy_(arr2, arr1, 9);
    printf("%s", arr2);
}
int main()
{
    text_1();//模拟实现strncpy
    return 0;
}

注意:不用关注‘\0’,源字符串拷贝到目标空间,多的部分就是‘\0’;


3.2strncat

源字符串的num个字符连接到目标空间

功能:

拷贝的字符数量大于源字符串长度时,不管多几个字符,都只添加1个‘\0’.

当要拷贝的字符数量小于源字符串长度时,自动添加’\0‘。

当要拷贝的字符数量小于源字符串长度时,自动添加’\0‘。

#include <stdio.h>
#include <assert.h>
char* my_strncat(char* dest,char* sur, int n)
{
    assert(dest);//断言目标空间不能为空
    assert(sur);
    char* cur = dest;
    while (*cur)//找到‘\0’跳出
    {
        cur++;
    }
    while (n--)//给目标空间赋值,赋了n次
    {
        *cur = *sur;
        cur++;
        sur++;
    }
    return dest;
}
void text_2()
    {
    char arr1[20] = "123456";
    char arr2[20] = "567890";
    my_strncat(arr1,arr2,8);
    printf("%s\n", arr1);
    }
int main()
{
    text_2();//模拟实现strncat
    return 0;
}

3.3strncmp

源字符串的num个字符与目标空间进行比较

功能:

字符串大小的比较是以ASCII 码表上的顺序来决定,此顺序为字符的值。strncmp()首先将dest 第一个字符值减去sur 第一个字符值,若差值为0 则再继续比较下个字符,直到字符结束标志’\0’,若差值不为0,则将差值返回。例如字符串"Ac"和"ba"比较则会返回差值(-33)

#include <stdio.h>
#include <assert.h>
int my_strncmp(char* dest, char* sur, int x)
{
    assert(dest);
    assert(sur);
    assert(x);
    while (--x && *dest == *sur && *dest && *sur)//两个字符不相等或者任意一个字符为空就跳出循环或比较完n个字符
    {
        dest++;
        sur++;
    }
   return  (*dest - *sur);
}
void text_3()
{
    char arr1[20] = "abcdef";
    char arr2[20] = "abCdeF";
    printf("%d\n", my_strncmp(arr1, arr2, 2));
}
int main()
{
    text_3();//模拟实现strncmp
    return 0;
}

四、字符串查找函数

4.1strstr

在字符串中找子字符串找不到返回NULL(空指针)

功能:strstr()是一个,参数为两个字符指针类型,返回值是char类型的函数,它用于找到子串(str2)在一个字符串(str1)中第一次出现的位置。这里因为传进来的地址指向的内容不会在发生改变,所以我们在两个形参(char)前加上const.

#include <stdio.h>
#include <assert.h>
const char* my_strstr(const char * str1, const char* str2)//模拟实现strstr
{
    char* s1=NULL, * s2=NULL, * cur = str1;
    if (str2 == '\0')
        return str1;
    while (*cur)
    {
        //指针回退
        s1 = cur;//把cur地址先存起来
        s2 = str2;//s2指向需要查找的子字符串首地址
        while (*s1 && *s2 && (*s1 == *s2))//*s1或者*s2或者两者不等的时候跳出循环
        {
            s1++;
            s2++;
        }
        if (*s2 == '\0')//找到了那个子字符串
        {
            return cur;
        }
        if (*s1 == '\0')//没有找到字符串
        {
            return NULL;
        }
        cur++; //当前cur指向的并不是子串第一次出现的首元素地址,指向的地址要往后跳一个字节
    }
    return NULL;//经过以上的循环比较,没有找到子字符串,返回空指针NULL
}
void text_4()
{
    char arr1[20] = "Acdef";
    char arr2[20] = "";
    char* ret=my_strstr(arr1, arr2);//在字符串arr1中找到子字符串2,返回第一次找到字符串2的位置
    if (ret == NULL)
        printf("没找到\n");
    else
        printf("找到了\n%s\n",ret);
}
int main()
{
    text_4();//模拟实现strstr
    return 0;
}

4.2strtok

把str字符串中由符号隔开的字段拿出来

功能

第一个参数是要分割的字符串,第二个参数是分割字符串的分隔符。

strtok函数找到str中的下一个标记(字段),并将其‘\0’结尾,返回一个指向这个标记的指针(strtok函数会改变被操作的字符串,所以在使用strtok函数切分字符串一般都是临时拷贝的内容并且可以被修改)

strtok函数第一个参数不为NULL,函数将找到str中的第一个标记,strtok函数将保存它在字符串中的位置。

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

如果字符串不存在更多的标记,则返回NULL指针。

#include <stdio.h>
#include <string.h>
void test_1()
{
    char str1[] = "yi_ge_xiao.nao@dai";
    char str[] = "_.@";
    char str2[25];//我们在使用strtok函数时会改变函数的第一个参数,所以我们在创建一个数组,不要用原字符串做参数
    strcpy(str2, str1);
    char* ret = strtok(str2, str);//第一个参数不为NULL,找到第一个字段,在字段后面吧分隔符换成‘\0’,strtok函数保存这个位置,返回字段的初始位置
    for (ret; ret != NULL;)//循环,把每个字段找出来
    {
        printf("%s ", ret);
        ret = strtok(NULL, str);//如果第一个参数为NULL,函数将在同一个字符串中被保存的位置开始,查找下一个标记。
    }
}
int main()
{
    test_1();//strtok的使用
    return 0;
}

打印结果:

五、错误信息报告(strerror)

功能:

把错误码翻译成错误信息

返回值:把错误码对应错误信息的字符串的首地址返回来。

库函数在执行的时候发生拉错位,会将错误码存放在errno这个变量中,errno是C语言提供的一个全局变量

如:


404->访问的页面不存在


例子:

#include <stdio.h>
#include <string.h>
 void test_2()
{
     int i = 0;
     for (i = 0; i < 10; i++)
     {
         printf("%d->%s\n", i, strerror(i));
     }
}
int main()
{
    test_2();//strerror的使用
    return 0;
}

打印结果:

表达的意思:

0->没有错误

1->操作被拒绝

2->没有这个文件或文件夹

3->没有这个进程

4->函数调用被中断

5->输入输出错误

6->没有这个设备和地址

7->参数列表太长

等……

如:

#include <stdio.h>
#include <string.h>
int main()
{
    //c语言中可以操作文件
    //操作文件的步骤
    //打开文件
    //读或者写
    //关闭文件
    //打印失败
    FILE* pf = fopen("data.txt","r");
    if (pf == NULL)
    {
        printf("%s\n", strerror(errno));//只打印错误信息
        //perror(“fopen”)//打印自定义信息(如fopen)然后加一个冒号和空格,在打印错误信息。
        return 1;
    }
    //读文件
    //关闭文件
    fclose(pf);
    return 0;
}

没有这个文件:


如果有多个错误:

用strerror(还可以用perror)只能一次翻译一个错误,如果一个问题有多个错误,先翻译第一个出现的错误,我们解决这个错误后,它会继续报另外的错误,所以我们遇到问题要及时更新。


六、字符操作函数

6.1字符分类函数

符合条件就打印非0值,不符合条件就打印0。


6.2字符转换函数

大写字母转换为小写字母函数(tolower)

小写字母转换为大写字母函数(toupper)

#include <stdio.h>
#include <string.h>
int main()
{
    printf("%c\n", tolower('A'));
    printf("%c\n", toupper('a'));
    return 0;
}

七、字符串大写和小写转换函数

字符串大写字母转换成小写字母函数(strlwr)

字符串小写字母转换成大写字母函数(strupr)

#include <stdio.h>
#include <string.h>
int main()
{
    char str1[] = "abcdEFGH1234";
    printf("%s\n", _strlwr(str1));
    printf("%s\n", _strupr(str1));
    return 0;
}

八、内存操作函数

8.1memcpy

用来处理不重叠的内存拷贝

有三个参数:

destination:一个指向目标数组的指针,它的内容将会被覆盖。

source:一个指向了被拷贝数据的那个指针。

num:拷贝几个字节(size_t就是unsigned int)

功能:函数memcpy从source位置开始向后复制num个字节的数据destination目标空间里,然后返回目标空间的初始地址。

这个函数遇到‘\0’的时候不会停下来。

如果source和destination有任何重叠的部分,复制的结果将未定义(结果于预料的值可能不一样)

memcpy函数的模拟实现

#include <stdio.h>
#include <string.h>
#include <assert.h>
 void* my_memcpy(void* dest, void* sur, size_t num)
 {
     assert(dest);
     assert(sur);
     void* ret = dest;
     while (num--)
     {
         *(char*)dest = *(char*)sur;//每个字节进行转换
         (char*)dest = (char*)dest + 1;//每个字节向后移一步
         (char*)sur = (char*)sur + 1;
     }
     return ret;
 }
 void test_3()
 {
     int str1[10] = { 1,2,3,4,5,6,7,8,9,10 };
     int str2[20] = {0};
     my_memcpy(str2, str1, 16);
     int i = 0;
     for (i = 0; i < 20; i++)
     {
         printf("%d ", str2[i]);
     }
 }
 int main()
{
    test_3();//mencpy的模拟实现
    return 0;
}


如果我们稍微改一下

结果变成了1 2 1 2 1 2 7 8 9 10

说明memcpy不能重叠内存拷贝


8.2memmove

可以处理重叠的内存拷贝

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

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

memmove函数的模拟实现

#include <stdio.h>
#include <string.h>
#include <assert.h>
 void* my_memmove(void* dest, void* sur, size_t num)
 {
     void* ret = dest;
     assert(dest);
     assert(sur);
     if (dest <= sur || ((char*)sur + num) <= (char*)dest)
     {
         while (num--)
         {
             *(char*)dest = *(char*)sur;//每个字节进行转换
             dest = (char*)dest + 1;//每个字节向后移一步
             sur = (char*)sur + 1;
         }
     }
     else
     {
         while (num--)//20
         {
             *((char*)dest+num) = *((char*)sur+num);//每个字节进行转换
         }
     }
     return ret;
 }
 void test_4()
 {
     int str1[10] = { 1,2,3,4,5,6,7,8,9,10 };
     my_memmove(str1 + 2, str1, 16);
     int i = 0;
     for (i = 0; i < 10; i++)
     {
         printf("%d ", str1[i]);
     }
 }
int main()
{
    test_4();//memmove函数的模拟实现
    return 0;
}

、打印:

在数组中,地址是由低到高得,如果dest的地址小于等于sur的地址,可以从前往后进行遍历拷贝;sur跳过num个的地址如果大于等于dest的地址可以从前往后遍历拷贝,也可以从后往前遍历拷贝。


8.3memset

内存设置

功能:填充内存块

ptr所指向的前num个字节的内容,设置成我们想要的value值(把所有字节都设置成一个值)

#include <stdio.h>
#include <string.h>
int main()//内存设置
{
    char arr[] = "panlongjun";
    memset(arr + 1, 'L', 2);
    printf("%s\n", arr);
    return 0;
}


8.4memcmp

内存比较函数(一个字节一个字节往后比较)

功能:

  1. ptr1大于ptr2,函数返回值为1
  2. ptr1小于ptr2,函数返回值为-1
  3. ptr1r等于ptr2,函数返回值为0
#include <stdio.h>
#include <string.h>
int main()//内存比较
{
    int arr1[] = { 1,2,1,4,5,6 };
    int arr2[] = { 1,2,257,12,34 };
    int ret = memcmp(arr1, arr2, 9);
    printf("%d\n", ret);
    return 0;
}

打印:

memcmp是内存比较函数,在内存空间里一个一个字节进行比较(比较9个字节,结果为0)


相关文章
|
11天前
|
C语言
【c语言】动态内存管理
本文介绍了C语言中的动态内存管理,包括其必要性及相关的四个函数:`malloc`、``calloc``、`realloc`和`free`。`malloc`用于申请内存,`calloc`申请并初始化内存,`realloc`调整内存大小,`free`释放内存。文章还列举了常见的动态内存管理错误,如空指针解引用、越界访问、错误释放等,并提供了示例代码帮助理解。
24 3
|
11天前
|
存储 算法 程序员
C语言:库函数
C语言的库函数是预定义的函数,用于执行常见的编程任务,如输入输出、字符串处理、数学运算等。使用库函数可以简化编程工作,提高开发效率。C标准库提供了丰富的函数,满足各种需求。
|
16天前
|
机器学习/深度学习 C语言
【c语言】一篇文章搞懂函数递归
本文详细介绍了函数递归的概念、思想及其限制条件,并通过求阶乘、打印整数每一位和求斐波那契数等实例,展示了递归的应用。递归的核心在于将大问题分解为小问题,但需注意递归可能导致效率低下和栈溢出的问题。文章最后总结了递归的优缺点,提醒读者在实际编程中合理使用递归。
41 7
|
16天前
|
存储 编译器 程序员
【c语言】函数
本文介绍了C语言中函数的基本概念,包括库函数和自定义函数的定义、使用及示例。库函数如`printf`和`scanf`,通过包含相应的头文件即可使用。自定义函数需指定返回类型、函数名、形式参数等。文中还探讨了函数的调用、形参与实参的区别、return语句的用法、函数嵌套调用、链式访问以及static关键字对变量和函数的影响,强调了static如何改变变量的生命周期和作用域,以及函数的可见性。
25 4
|
14天前
|
存储 C语言
【c语言】字符串函数和内存函数
本文介绍了C语言中常用的字符串函数和内存函数,包括`strlen`、`strcpy`、`strcat`、`strcmp`、`strstr`、`strncpy`、`strncat`、`strncmp`、`strtok`、`memcpy`、`memmove`和`memset`等函数的使用方法及模拟实现。文章详细讲解了每个函数的功能、参数、返回值,并提供了具体的代码示例,帮助读者更好地理解和掌握这些函数的应用。
14 0
|
14天前
|
C语言
【c语言】qsort函数及泛型冒泡排序的模拟实现
本文介绍了C语言中的`qsort`函数及其背后的回调函数概念。`qsort`函数用于对任意类型的数据进行排序,其核心在于通过函数指针调用用户自定义的比较函数。文章还详细讲解了如何实现一个泛型冒泡排序,包括比较函数、交换函数和排序函数的编写,并展示了完整的代码示例。最后,通过实际运行验证了排序的正确性,展示了泛型编程的优势。
15 0
|
17天前
|
算法 C语言
factorial函数c语言
C语言中实现阶乘函数提供了直接循环和递归两种思路,各有优劣。循环实现更适用于大规模数值,避免了栈溢出风险;而递归实现则在代码简洁度上占优,但需警惕深度递归带来的潜在问题。在实际开发中,根据具体需求与环境选择合适的实现方式至关重要。
16 0
|
26天前
|
C语言 C++
C语言 之 内存函数
C语言 之 内存函数
31 3
|
17天前
|
存储 缓存 C语言
【c语言】简单的算术操作符、输入输出函数
本文介绍了C语言中的算术操作符、赋值操作符、单目操作符以及输入输出函数 `printf` 和 `scanf` 的基本用法。算术操作符包括加、减、乘、除和求余,其中除法和求余运算有特殊规则。赋值操作符用于给变量赋值,并支持复合赋值。单目操作符包括自增自减、正负号和强制类型转换。输入输出函数 `printf` 和 `scanf` 用于格式化输入和输出,支持多种占位符和格式控制。通过示例代码详细解释了这些操作符和函数的使用方法。
31 10
|
21天前
|
存储 编译器 C语言
C语言函数的定义与函数的声明的区别
C语言中,函数的定义包含函数的实现,即具体执行的代码块;而函数的声明仅描述函数的名称、返回类型和参数列表,用于告知编译器函数的存在,但不包含实现细节。声明通常放在头文件中,定义则在源文件中。