AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【c语言】字符串函数和内存函数

2024-10-30 42
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 本文介绍了C语言中常用的字符串函数和内存函数，包括`strlen`、`strcpy`、`strcat`、`strcmp`、`strstr`、`strncpy`、`strncat`、`strncmp`、`strtok`、`memcpy`、`memmove`和`memset`等函数的使用方法及模拟实现。文章详细讲解了每个函数的功能、参数、返回值，并提供了具体的代码示例，帮助读者更好地理解和掌握这些函数的应用。

前言

       在编程的过程中，我们经常要对字符串和内存进行各种各样的处理，c语言提供了一系列字符串函数和内存函数，便于我们对字符串或者内存空间进行操作。本篇文章我们就来学习其中的一些函数。


一、字符串函数

1.strlen的使用和模拟实现

       c语言中，strlen函数用于计算一个字符串的长度。它的原型如下：


size_t  strlen ( const char * str ) ;


这里需要注意的是：

1.字符串以\0为结束标志，这个函数返回值是字符串的长度，不包括\0。

2.传参时要传入字符、0串的首元素地址，指向的字符串要以\0为结尾。

3.函数返回值类型是size_t，是一个无符号整数

4.strlen函数使用需要引头文件string.h


接下来我们试着使用一下strlen函数：

#include <stdio.h>
#include<string.h>
 
int main()
{
    char str[] = "hello";
    int ret = strlen(str);
    printf("%d\n", ret);
    return 0;
}

运行结果：



可以看到，"hello"一共有五个字符，所以字符串的长度就是5。也就是说，这个函数的原理就是统计出\0之前的字符个数。这样，我们尝试模拟实现一下它：


方法1：计数器

size_t my_strlen(const char* str)
{
    size_t count = 0;//定义变量统计字符个数
    while (*str != '\0')
    {
        str++;
        count++;
    }
    return count;
}

这里我们定义了一个变量count，负责统计\0之前的字符个数。当指针走到\0处时，循环停止。


方法2：递归

size_t my_strlen(const char* str)
{
    size_t count = 0;//定义变量统计字符个数
    while (*str != '\0')
    {
        str++;
        count++;
    }
    return count;
}

方法3：指针减指针

size_t my_strlen(const char* str)
{
    char* p = str;
    while (*str++);//指针持续往后走，知道遇到\0为止
    return str - p - 1;//后置++使得指针多走了一步，多减一个1
}

这里先记录一下首元素地址，然后让str跑到字符串末尾，再减去首元素地址就得到两地址之间的元素个数，也就是字符串长度。


2.strcpy的使用和模拟实现

       strcpy这个函数的作用是将源字符串中的内容拷贝到目标字符串中。它的原型如下：


char* strcpy ( char* dest, const char* src ) ;


这里需要注意：

1.第一个参数是目标字符串的首地址，第二个参数是源字符串的首地址。

2.源字符串必须以\0结尾。

3.目标字符串的空间必须足够大，能够包含整个源字符串；目标字符串不能是常量字符串。

4.函数返回值是目标字符串的首元素地址。

5.源字符串中的\0也会一同拷贝。


我们尝试使用一下它：

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

运行结果：



模拟实现：

char* my_strcpy(char* dest,const char* src)
{
    char* ret = dest;//记录首元素地址
    while (*dest++ = *src++);
    return ret;
}

这里我们首先记录了原字符串的首地址，然后循环赋值完成拷贝，最后返回首地址。


3.strcat的使用和模拟实现

       strcat函数的作用是将源字符串内容追加到目标字符串上。原型如下：


char * strcat ( char * dest, const char * src ) ;


要注意的是：

1.第一个参数是目标字符串的首地址，第二个参数是源字符串的首地址。

2.源字符串和目标字符串都必须以\0结尾。

3.目标字符串的空间必须足够大；目标字符串不能是常量字符串。

4.函数返回值是目标字符串的首地址。


接着我们使用一下这个函数：

#include <stdio.h>
#include <string.h>
 
int main()
{
    char str1[20] = "hello ";
    char str2[] = "world";
    printf("%s\n", strcat(str1, str2));
    return 0;
}

运行结果：



模拟实现：

char* my_strcat(char* dest, const char* src)
{
    char* ret = dest;//记录目标字符串首地址
    while (*dest)
    {
        dest++;
    }//使指针指向目标字符串末尾
    while (*dest++ = *src++);//循环追加，直到源字符串末尾
    return ret;
}

4.strcmp的使用和模拟实现

       strcmp函数是一个很重要的函数，它用于比较两个字符串的大小。字符串的比较在很多实例中会使用到，它的比较规则如下：



在了解了比较规则之后，我们来看一下函数原型：


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


1.参数传入要比较的两个字符串的首地址。

2.两个字符串都要以\0结尾。

3.如果str1大于str2，函数返回正数，否则返回负数，相等则返回0。


我们写一个程序使用该函数，实现两个字符串比较：

#include <stdio.h>
#include <string.h>
 
int main()
{
    char str1[] = "abcd";
    char str2[] = "abdc";
    int flag = strcmp(str1, str2);
    if (flag > 0)
    {
        printf("str1大于str2\n");
    }
    else if (flag < 0)
    {
        printf("str1小于str2\n");
    }
    else
    {
        printf("两者相等\n");
    }
    return 0;
}

运行结果：



接着，我们尝试模拟实现strcmp：

int my_strcmp(const char* str1, const char* str2)
{
    while (*str1 == *str2)
    {
        if (*str1 == '\0')//处理出现空字符串或者字符比较到末尾的情况
        {
            return 0;
        }
        str1++;
        str2++;
    }
    return *str1 - *str2;
}

5.strstr的使用和模拟实现

       接下来，我们学习一下strstr函数。strstr函数的作用是判断一个字符串是否是另一个字符串的子字符串（是否为包含关系）。


它的原型如下：


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


1.两个字符串必须要以\0结尾。

2.函数的返回值是str2在str1中第一次出现的位置，如果没找到，返回空指针。

我们尝试使用这个函数：

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

运行结果：



可以看到，函数确实找到了第二个字符串在第一个字符串中的位置。接下来我们模拟实现一下它：

char* my_strstr(const char* str1, const char* str2)
{
    char* cur = str1;
    if (*str2 == '\0')//空字符串的情况
    {
        return str1;
    }
    while (*cur != '\0')
    {
        char* s1 = cur;
        char *s2 = str2;
        while (*s1 && *s2 && (*s1 - *s2) == '\0')//遍历相等的部分
        {
            s1++;
            s2++;
        }
        if (*s2 == '\0')//遍历结束后如果str2已结束，说明是子串
        {
            return cur;
        }
        cur++;
    }
    return NULL;
}

6.strncmp、strncpy、strncat的使用

       这三个函数是在原来功能的基础之上，限定了比较/拷贝/追加的字符个数。函数的参数部分多了一个num，表示限定的字符个数。举个例子：

#include <stdio.h>
#include <string.h>
 
int main()
{
    char str1[] = "xxxxxxxxx";
    char str2[] = "hehe";
    strncpy(str1, str2, 2);
    printf("%s\n", str1);
    char str3[20] = "hello ";
    char str4[] = "world";
    strncat(str3, str4, 3);
    printf("%s\n", str3);
    return 0;
}

运行结果：



可以看到，程序根据我们限定的字符个数完成了拷贝和追加。


7.strtok的使用

       strtok函数也叫做字符串分割函数。顾名思义，它的作用就是根据给出的特定字符来分割字符串。下面是它的原型：


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


这里需要注意以下几点：

1.第一个参数是要被分割的字符串，第二个参数是由分隔符组成的字符串。

2.strtok函数会在str中寻找限定的分隔符，遇到分隔符就会在字符串中将其变为\0，完成分割。函数返回上一次分割后\0的下一个字符的地址；如果是第一次分割，则返回字符串首地址。

3.对一个字符串进行多次分割时，需要多次调用该函数：第一次调用时str传入要被分割的字符串，函数会使用静态变量保存被分割的位置，之后调用时str要传入NULL，函数就会从保存的位置开始进行分割。

4.当字符串按照分隔符完成了所有分割之后，就会返回NULL。

我们写代码体现一下它的使用效果：

#include <stdio.h>
#include <string.h>
 
int main()
{
    char str[] = "123.12.14.1.50";
    char* p = NULL;
    printf("%s\n", str);
    for (p = strtok(str, "."); p != NULL; p = strtok(NULL, "."))
    {
        printf("%s\n", p);
    }
    return 0;
}

运行结果：



可以看到字符串成功被分割成几部分。不难发现，strtok函数可以和for循环结合使用，达到分割字符串的效果。


二、内存函数

       在学习了这些字符串函数之后，我们可以发现，它们虽然实用，但是却只能对字符串进行操作。那么是否有一些函数可以让我们对任何类型也进行相似操作呢？它就是内存函数。这些内存函数的使用也需要引头文件string.h。


1.memcpy的使用和模拟实现

       memcpy函数也叫做内存拷贝函数，它能够将特定字节的内存值拷贝到其他内存位置中。它的原型：


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


其中的前两个参数分别表示目标空间和源空间的首地址，第三个参数表示要拷贝的字节数。函数的返回值是目标空间的首地址。我们来使用一下它：

#include <stdio.h>
#include <string.h>
 
int main()
{
    int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int arr2[10] = { 0 };
    memcpy(arr2, arr1, 5 * sizeof(int));
    for (int i = 0; i < 10; i++)
    {
        printf("%d ", arr2[i]);
    }
    return 0;
}

运行结果：



可以看到，有五个元素的内容被拷贝到arr2当中。


接下来我们尝试模拟实现：

void* my_memcpy(void* dest, const void* src, size_t num)
{
    void* ret = dest;
    while (num--)
    {
        *(char*)dest = *(char*)src;
        (char*)dest += 1;//这里由于强制类型转换是临时的，不能直接写++
        (char*)src += 1;
    }
    return ret;
}

可以看出，我们这里使用了泛型编程的思想，将void*指针强转为char*类型，然后根据给定的字节数一个字节一个字节赋值。


2.memmove的使用和模拟实现

       对于刚才的memcpy函数，如果想要拷贝的两个内存空间之间出现重叠情况，那么函数就无法完成正常的拷贝。而memmove函数就弥补了这个缺陷。原型如下：


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


它的参数含义和返回值和memcpy是完全相同的。我们尝试使用它来拷贝重叠的内存：

#include <stdio.h>
#include <string.h>
 
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    memmove(arr, arr + 2, 5 * sizeof(int));
    for (int i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

运行结果：



可以看到，它成功地完成了重叠内存的拷贝。那我们是否可以模拟实现这个函数呢？


我们首先来思考一下，现在有一个数组arr，它的内容如下：



现在我们想要将1，2，3，4，5这五个元素拷贝到3，4，5，6，7的位置上，能否完成呢？


将1赋值到3的位置上，将2赋值到4的位置上，到赋值3的时候，就会发现，此时的3已经被覆盖成1了，这样下去，最终结果就会变成1，2，1，2，1，2，1，8，9，10。


聪明的你肯定会想到，既然从前往后不行，那么我们就从后往前进行拷贝：先将5赋值到7的位置，再将4赋值到6的位置，以此类推...你就会发现结果就是1，2，1，2，3，4，5，8，9，10，说明成功了。


难道所有的情况都可以通过从后往前拷贝的方法赋值成功吗？当我们反过来将3，4，5，6，7拷贝到1，2，3，4，5的位置上，我们就发现从后往前的拷贝就不行了，就要用从前往后拷贝的方式。


所以我们就可以得出以下结论：在有重叠空间的情况下，如果dest的地址小于src,那么就从前向后拷贝；如果dest的地址大于src，就从后向前拷贝。没有重叠空间时怎样都行。图示：



这里由于右边非重叠空间的部分和中间部分是连续的，所以我们使用从后向前拷贝的方法会更加方便编写代码。


代码如下：

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

3.memset的使用

       memset函数也叫做内存设置函数，它可以对特定区域的内存全部赋成你想要的值。它的原型如下：


void * memset ( void * ptr, int value, size_t num ) ；


它的第一个参数是要设置的内存空间的首元素地址，第二个参数是要赋的值，第三个参数是内存空间的大小（字节）。

它的返回值是内存空间的首元素地址。


我们来使用一下这个函数：

#include <stdio.h>
#include <string.h>
 
int main()
{
    char str[] = "hello world";
    memset(str, 'x', 6);
    printf(str);
    return 0;
}

运行结果：



可以看到，前六个字符都被赋值成了'x'。


总结

       本篇文章我们学习了字符串函数和内存函数的相关知识，它们在我们的编程当中十分常见和实用。同时，我们也学会了如何思考问题，解决问题。之后博主会更新数据存储方式相关的内容。如果你觉得博主讲的还不错，就请留下一个小小的赞在走哦，感谢大家的支持❤❤❤

文章标签：
C语言
存储
关键词：
C语言函数
C语言内存
内存函数
C语言内存函数
c语言字符串函数内存
ephemerals__
目录
相关文章
LuckiBit
|
29天前
|
存储 C语言 开发者
【C语言】字符串操作函数详解
这些字符串操作函数在C语言中提供了强大的功能，帮助开发者有效地处理字符串数据。通过对每个函数的详细讲解、示例代码和表格说明，可以更好地理解如何使用这些函数进行各种字符串操作。如果在实际编程中遇到特定的字符串处理需求，可以参考这些函数和示例，灵活运用。
LuckiBit
58 10
LuckiBit
|
29天前
|
存储 程序员 C语言
【C语言】文件操作函数详解
C语言提供了一组标准库函数来处理文件操作，这些函数定义在 `<stdio.h>` 头文件中。文件操作包括文件的打开、读写、关闭以及文件属性的查询等。以下是常用文件操作函数的详细讲解，包括函数原型、参数说明、返回值说明、示例代码和表格汇总。
LuckiBit
46 9
LuckiBit
|
29天前
|
存储 Unix Serverless
【C语言】常用函数汇总表
本文总结了C语言中常用的函数，涵盖输入/输出、字符串操作、内存管理、数学运算、时间处理、文件操作及布尔类型等多个方面。每类函数均以表格形式列出其功能和使用示例，便于快速查阅和学习。通过综合示例代码，展示了这些函数的实际应用，帮助读者更好地理解和掌握C语言的基本功能和标准库函数的使用方法。感谢阅读，希望对你有所帮助！
LuckiBit
40 8
LuckiBit
|
29天前
|
C语言 开发者
【C语言】数学函数详解
在C语言中，数学函数是由标准库 `math.h` 提供的。使用这些函数时，需要包含 `#include <math.h>` 头文件。以下是一些常用的数学函数的详细讲解，包括函数原型、参数说明、返回值说明以及示例代码和表格汇总。
LuckiBit
47 6
LuckiBit
|
29天前
|
存储 C语言
【C语言】输入/输出函数详解
在C语言中，输入/输出操作是通过标准库函数来实现的。这些函数分为两类：标准输入输出函数和文件输入输出函数。
LuckiBit
218 6
LuckiBit
|
29天前
|
存储 缓存 算法
【C语言】内存管理函数详细讲解
在C语言编程中，内存管理是至关重要的。动态内存分配函数允许程序在运行时请求和释放内存，这对于处理不确定大小的数据结构至关重要。以下是C语言内存管理函数的详细讲解，包括每个函数的功能、标准格式、示例代码、代码解释及其输出。
LuckiBit
59 6
warmhearted
|
2月前
|
缓存 Prometheus 监控
Elasticsearch集群JVM调优设置合适的堆内存大小
Elasticsearch集群JVM调优设置合适的堆内存大小
warmhearted
322 1
游客vsgxb64qlj7cg
|
26天前
|
存储 监控 算法
深入探索Java虚拟机（JVM）的内存管理机制
本文旨在为读者提供对Java虚拟机（JVM）内存管理机制的深入理解。通过详细解析JVM的内存结构、垃圾回收算法以及性能优化策略，本文不仅揭示了Java程序高效运行背后的原理，还为开发者提供了优化应用程序性能的实用技巧。不同于常规摘要仅概述文章大意，本文摘要将简要介绍JVM内存管理的关键点，为读者提供一个清晰的学习路线图。
游客vsgxb64qlj7cg
67 3
爱吃香蕉的猫
|
2月前
|
Java
JVM内存参数
-Xmx[]:堆空间最大内存 -Xms[]:堆空间最小内存，一般设置成跟堆空间最大内存一样的 -Xmn[]:新生代的最大内存 -xx[use 垃圾回收器名称]：指定垃圾回收器 -xss:设置单个线程栈大小 一般设堆空间为最大可用物理地址的百分之80
爱吃香蕉的猫
26 4
Skyund
|
2月前
|
Java
JVM运行时数据区（内存结构）
1）虚拟机栈：每次调用方法都会在虚拟机栈中产生一个栈帧，每个栈帧中都有方法的参数、局部变量、方法出口等信息，方法执行完毕后释放栈帧 （2）本地方法栈：为native修饰的本地方法提供的空间，在HotSpot中与虚拟机合二为一 （3）程序计数器：保存指令执行的地址，方便线程切回后能继续执行代码
Skyund
22 3

热门文章

最新文章

  • 1
    【C语言】深入浅出：C语言链表的全面解析
  • 2
    【C语言】输入/输出函数详解
  • 3
    【C语言】宏定义详解
  • 4
    C 语言中所有可用的关系运算符
  • 5
    【c语言】运算符汇总（万字解析）
  • 6
    【C语言】结构体详解 -《探索C语言的 “小宇宙” 》
  • 7
    【C语言】enum 关键字详解
  • 8
    C 语言中的数据类型转换：连接不同数据世界的桥梁
  • 9
    【C语言】原码、反码、补码详解 -《码上有道 ! 》
  • 10
    【C语言】深入解析C语言结构体：定义、声明与高级应用实践
  • 1
    Python内存管理与垃圾回收机制
    69
  • 2
    【MongoDB 专栏】MongoDB 的内存管理与优化
    354
  • 3
    JavaScript的垃圾回收机制通过标记-清除算法自动管理内存
    60
  • 4
    LabVIEW使用数据引用减少内存
    73
  • 5
    linux上如何排查JVM内存过高？
    1101
  • 6
    Redis内存分析工具RDR
    1775
  • 7
    LabVIEW中CPU和内存使用情况在NI分布式系统管理器中不可见
    90
  • 8
    LabVIEW监控实时嵌入式目标上的CPU和内存使用情况
    281
  • 9
    LabVIEW最大内存块属性不存在
    40
  • 10
    LabVIEW性能和内存管理 8
    72

    • 相关课程

    更多
  • 你的第一门C语言课
  • C语言学习教程
  • Go语言核心编程 - 基础语法、数组、切片、Map

    • 相关电子书

    更多
  • 内存取证与IaaS云平台恶意行 为的安全监控
  • 云服务器ECS内存增强型实例re6全新发布
  • 低代码开发师（初级）实战教程

    • 相关实验场景

    更多
  • 函数类型-3：函数重载
  • 函数类型-1：基本语法
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)