【C语言】内存函数介绍

最新推荐文章于 2024-10-02 21:02:12 发布
最新推荐文章于 2024-10-02 21:02:12 发布
阅读量497 收藏 11
点赞数 17
文章标签： c语言 经验分享 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73575817/article/details/128651227
版权

它们所在的头文件：

（这里出现的arr都为char类型数组）

    • strlen

作用：计算一个字符串的长度

本质：历经千辛找一个 \0 ，找到 \0 就立马停止。（就是找 \0 ）

易错：strlen 返回值为 size_t ，易错点

strlen 的模拟实现：

//方法一
#include <stdio.h>
#include <assert.h>

int my_strlen(const char* str)
{
    assert(str != NULL);
    const char* soc = str;

    while (*soc++ != '\0')
    {
        ;
    }

    return soc - str - 1;

}

int main()
{
    char arr[20] = { 0 };
    scanf("%s", arr);

    printf("%d", my_strlen(arr));

    return 0;
}


//方法二
//#include <stdio.h>
//#include <assert.h>
//
//int my_strlen(const char* str)
//{
//    assert(str != NULL);
//    int count = 0;
//
//    while (*str++ != '\0')
//    {
//        count++;
//    }
//
//    return count;
//
//}
//
//int main()
//{
//    char arr[20] = { 0 };
//    scanf("%s", arr);
//
//    printf("%d\n", my_strlen(arr));
//
//    return 0;
//}


//方法三
//#include <stdio.h>
//#include <assert.h>
//
//int my_strlen(const char* str)
//{
//    assert(str != NULL);
//    
//    if (*str++ != '\0')
//    {
//        return 1 + my_strlen(str);
//    }
//    else
//    {
//        return 0;
//    }
//
//}
//
//int main()
//{
//    char arr[20] = { 0 };
//    scanf("%s", arr);
//
//    printf("%d\n", my_strlen(arr));
//
//    return 0;
//}
//

2、strcpy 和 strncpy

strcpy

格式： strcpy(arr1, arr2);

作用：将源字符串拷贝到目标字符串

核心：

while (*str1 = *str2)

{

;

}

（将arr2的内容全部赋给arr1， 不管arr1里面是什么，只要放的下就行）

一旦知道了其核心，就知道它相关的细节问题：

如上 arr2 的 \0 赋过去时才停止，所以会把 arr2 的 \0 赋过去

就是要注意，目标空间（arr1）够大，放得下 arr1；并且是可修改空间（arr1内容不能是字符常量）

strcpy模拟实现：

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


char* my_strcpy(char* str1, const char* str2)
{
    assert(str1 != NULL);
    assert(str2 != NULL);

    while (*str1++ = *str2++)
    {
        ;
    }

}



int main()
{
    char arr1[20] = { 0 };
    char arr2[20] = { 0 };
    scanf("%s", arr1);
    scanf("%s", arr2);

    my_strcpy(arr1, arr2);

    printf("%s", arr1);

    return 0;
}

strncpy

格式：strncpy(arr1, arr2, num);

作用：将源字符串的 num 个字符拷贝到目标字符串

核心内容：

除了返回值，不同在于循环时多了个条件来限制给值

while (num && (*str1++ = *str2++))

{

num--;

}

模拟实现：

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

char* my_strncmp(char* str1, const char* str2, size_t num)
{
    assert(str1 != NULL);
    assert(str2 != NULL);

    while (num && (*str1++ = *str2++))
    {
        num--;
    }

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

    return str1;

}


int main()
{
    char arr1[20] = { 0 };
    char arr2[20] = { 0 };
    scanf("%s", arr1);
    scanf("%s", arr2);

    my_strncmp(arr1, arr2, 3);

    printf("%s\n", arr1);

    return 0;
}

3、strcmp 和 strncmp

srtcmp

作用：比较两个字符串对应位置上的字符

格式：strcmp(arr1, arr2);

返回值：（相等比下一个，直到结束）

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

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

若对应字符全都相等，才返回0

（visual stdio中大于0是返回1，小于0返回-1， 其他环境下不一定）

模拟实现 stcmp：

//实现strcmp
#include <stdio.h>
#include <assert.h>

int my_strcmp(const char* str1, const char* str2)
{
    assert(str1 != NULL);
    assert(str2 != NULL);

    while (*str1 == *str2)
    {
        if (*str1 == 0)
        {
            return 0;
        }

        str1++;
        str2++;
    }

    if (*str1 > *str2)
    {
        return 1;
    }
    else
    {
        return -1;
    }

    /*return *str1 - *str2;*/

}

int main()
{
    char arr1[20] = { 0 };
    char arr2[20] = { 0 };
    scanf("%s", arr1);
    scanf("%s", arr2);

    int ret = my_strcmp(arr1, arr2);

    printf("%d\n", ret);

    return 0;
}

strncmp

作用：比较两个字符串 num 个数前的字符

格式：strncmp(arr1, arr2, num);

返回值标准和 strcmp 一样

模拟实现（简易版）：

//实现简易strcmp
#include <stdio.h>
#include <assert.h>

int my_strncmp(const char* str1, const char* str2, size_t num)
{
    assert(str1 != NULL);
    assert(str2 != NULL);

    while ((*str1 == *str2) && num)
    {
        if (*str1 == 0)
        {
            return 0;
        }

        str1++;
        str2++;
        num--;
    }

    if (!num)
    {
        return 0;
    }

    if (*str1 > *str2)
    {
        return 1;
    }
    else if (*str1 < *str2)
    {
        return -1;
    }

    /*return *str1 - *str2;*/

}

int main()
{
    char arr1[20] = { 0 };
    char arr2[20] = { 0 };
    scanf("%s", arr1);
    scanf("%s", arr2);

    size_t num = 0;
    scanf("%u", &num);

    int ret = my_strncmp(arr1, arr2, num);

    printf("%d\n", ret);

    return 0;
}

4、strcat 和 strncat

strcat

作用：在一个目标字符串后追加字符串

格式：strcat(arr1, arr2);

意思是在 arr1 后追加一个 arr2

etc. arr1 = "abcde"; arr2 = "abc";

strcat (arr1, arr2); 这样的结果是：arr1里的内容变成： abcdeabc\0

strcat(arr1, "abcdef"); （例二）

模拟实现：

//模拟实现 strcat
#include <stdio.h>
#include <assert.h>

char* my_strcat(char* str1, const char* str2)
{
    assert(str1 && str2);
    char* soc = str1;

    while (*str1)
    {
        str1++;
    }

    while (*str1++ = *str2++)
    {
        ;
    }

    return soc;

}


int main()
{
    char arr1[20] = { 0 };
    char arr2[20] = { 0 };
    scanf("%s", arr1);
    scanf("%s", arr2);

    my_strcat(arr1, arr2);

    printf("%s", arr1);

    return 0;
}

strncat

作用：和strcat差不多，在目标字符串后追加一定数目的字符（变得可以控制长度）

格式：strncat(arr1, arr2, 4);

意思是在 arr1 后追加一个 arr2 里的前 4 个字符

etc. arr1 = "abcdef"; arr2 = "abcde";

strncat (arr1, arr2, 4); 这样的结果是：arr1里的内容变成： abcdeabcd\0

strncat(arr1, "abcdef", 5); （例二）

模拟实现 strncat：

//模拟实现 strncat
#include <stdio.h>
#include <assert.h>

char* my_strncat(char* str1, const char* str2, size_t num)
{
    assert(str1 && str2);
    char* soc = str1;

    while (*str1)
    {
        str1++;
    }

    while (num-- && (*str1++ = *str2++))
    {
        ;
    }

    return soc;

}


int main()
{
    char arr1[20] = { 0 };
    char arr2[20] = { 0 };
    scanf("%s", arr1);
    scanf("%s", arr2);

    size_t num = 0;
    scanf("%u", &num);

    my_strncat(arr1, arr2, num);

    printf("%s", arr1);

    return 0;
}

5、strstr

作用：寻找字符串arr1中 是否存在 字符串arr2

格式：strstr(arr1, arr2);

意思是寻找 arr1 里的子字符串 有没有和 arr2 相等的

有 就返回：arr1里 目标字符串的首字符地址 （可能不止存在一个，返回找到的第一个子字符串手字符地址）

etc. arr1 = "abcde"; arr2 = "abc";

strstr(arr1, arr2); 返回的结果是arr1中字符 'a' 的地址

模拟实现：

//简易版
#include <stdio.h>
#include <assert.h>
#include <string.h>


int my_strncmp(const char* str1, const char* str2, int sz)
{
    while (sz-- && (*str1 == *str2))
    {
        if (0 == sz)
        {
            return 0;
        }

        str1++;
        str2++;
    }

    return 1;

}


char* my_strstr(const char* str1, const char* str2)
{
    assert(str1 != NULL);
    assert(str2 != NULL);

    size_t sz1 = strlen(str1);
    size_t sz2 = strlen(str2);

    if (sz1 < sz2)
    {
        printf("非法输入\n");
    }

    for (int i = 0; i <= sz1 - sz2; i++)
    {
        char* soc = str2;
        //abcdef
        //cde

        if (!my_strncmp(str1, soc, sz2))
        {
            return str1;
        }

        str1++;

    }

    return NULL;

}

int main()
{
    char arr1[20] = { 0 };
    char arr2[20] = { 0 };
    scanf("%s", arr1);
    scanf("%s", arr2);

    char* p = my_strstr(arr1, arr2);

    if (p != NULL)
    {
        printf("\n\n是否存在：存在\n");
        printf("\n打印符合要求字符串及后面的全部字符：%s\n", p);
    }
    else
    {
        printf("\n存在情况：不存在 (null)\n");
    }

    return 0;
}

6、strtok

作用：将一串带有特殊符号的字符串分隔开（特殊符号一般指标点如 '.' 、'@' 、' * ' ）

etc. zhuzhu@yxr.com

strtok 函数可以将上面字符串分割成 "zhuzhu" ,"yxr", "com"

格式：char*strtok ( char*strToken, constchar*strDelimit );

作用的原理是将特殊字符变为 '\0' ，所以实现得先将特殊字符写成一串字符串，放到一个指针里（等下传参也这样规定）

函数第一个参数为要被分隔的字符串；第二个参数为指向分隔符的指针，实现准备好了穿过指针去就OK

返回值：返回该次 “截剪” 的字符串首元素地址 （如上使用一次strtok，返回字符 'z' 的地址）；最后分隔符找完会返回 NULL

细节：因为其作用原理（是将分隔符赋为'\0'），所以会改变传过去的字符串内容，当我们不想一个字符串被改变时，可以先把字符串拷贝一份，再传过去

注意使用一次strtok只是将第一个要分隔的地方进行分隔，相当于还没“剪完”，所以要多次使用 ———> 想到循环

而第二次使用时：

第一个参数只要传 NULL 空指针就好，strtok会记录上次改 \0 的位置，在其后再寻找分隔符（第二次：strtok(NULL, pc) ）

（可猜出strtok函数中使用了statistic，以至于一些数据一直存在不被销毁）

基本用法：（基本循环写法）

7、strerror

#include

当程序出现各种错误时，每周错误对应一个数字编码，如果只把数字编码反馈出来给我们看，看不懂反正我不看

而 strerror 相当于一个翻译官，可以将这些数字编码转化，返回一个字符串首元素地址，这串对应的字符串就是我们可以看得懂的错误信息，返回该地址后我们用printf来打印，就可以知道错误信息

头文件：

格式：strerror(errno)

作用：返回错误信息

具体用法：

首先的知道当产生错误后，用时也会产生一个数字编码，而这个数字编码存放在哪里呢？是存放在errno这个变量里

所以使用 strerror 时，我们要到 errno 这个变量里去拿到数字编码，所以格式为 strerror(errno)

etc. printf("%s", strerror(errno) );

8、memcpy

格式：memcpy(arr1, arr2, num);

作用：拷贝源空间到目标空间

一定要注意 num 的单位，字节为单位

所以传num时，num = 1字节 * 类型大小 * 拷贝个数

etc. num = 1 * 4 * 要拷贝整型数的个数

模拟实现初级memcpy：（该版本不能拷贝自身局部内容）

//memcpy 的初级实现（移植性强版本）
#include <stdio.h>
#include <assert.h>

void* my_memcpy(void* dest, const void* src, size_t num)
{
    assert(dest && src);
    void* soc = dest;

    while (num--)
    {
        *(char*)dest = *(char*)src;
        dest = (char*)dest + 1;
        src = (char*)src + 1;
    }

    return soc;

}

int main()
{
    /*char arr1[20] = { 0 };
    char arr2[20] = { 0 };
    scanf("%s", arr1);
    scanf("%s", arr2);*/

    int arr1[20] = { 1, 2, 3, 4, 5 };
    int arr2[20] = { 6, 7, 8, 9, 10 };

    size_t num = 0;
    scanf("%zu", &num);

    my_memcpy(arr1, arr2, num);

    /*printf("%s", arr1);*/

    for (int i = 0; i < 5; i++)
    {
        printf("%d ", *(arr1 + i));
    }

    return 0;
}

9、memmove （与memcpy很相似）

格式：memmove(arr1, arr2, num);

作用：拷贝源空间到目标空间

一定要注意 num 的单位，字节为单位（和memcpy一样）

所以传num时，num = 1字节 * 类型大小 * 拷贝个数

etc. num = 1 * 4 * 要拷贝整型数的个数

模拟实现初级memmove：

//memmove 的初级实现
#include <stdio.h>
#include <assert.h>

#define count 1000

void* my_memcpy(void* dest, const void* src, size_t num)
{
    assert(dest && src);
    void* soc = dest;

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

}

int main()
{
    int arr[20] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    size_t num = 0;
    printf("请输入要移动的字节数：");
    scanf("%zu", &num);

    my_memcpy(arr + 2, arr, num);

    /*printf("%s", arr1);*/

    for (int i = 0; i < 10; i++)
    {
        printf("%d ", *(arr + i));
    }

    return 0;
}

10、一些常见的字符函数

这些函数直接使用就好了，如果记不住那就去记就好啦（可能可以在一些时候帮忙哦）

相关试题就放到后面再更新咯，大家记得电赞哦，不然晚上会梦见小只因哦（真的，昨天晚上我就梦见了）

Meiyourou.c
关注
c语言内存函数
roseisbule的博客
02-13 1164
c语言有操作内存的函数，分别为：malloc，realloc，calloc，free。 为什么要有内存函数？ 从个人的感受来讲，在开发一个通讯录时，每个人的通讯录都是不一样的，这就很难确定需要给结构体数组创建多大的内存。如果不使用内存函数，那么就是简单粗暴地将结构体数组设成非常大，这很难不浪费内存。 malloc： void* malloc (size_t size); 1.malloc函数负责向内存申请一块连续的空间，如果申请成功，则返回空间的地址，如果申请失败，则返回NULL。 2.由于不
C语言函数详解
热门推荐
qq_65285898的博客
04-26 8万+
函数作为C语言的基本组成元素，让我们深入认识这个熟悉又陌生的朋友
C语言之内存函数
weixin_61183404的博客
02-10 1518
内存函数：通常指的是在编程中用于处理内存操作的函数，这些函数可以用来分配、释放、复制、比较等内存相关的操作。在C语言中，这些内存函数 、、、 都需要引用头文件 。 函数的原型如下： ：目标内存地址，即要将数据复制到的位置。 ：源内存地址，即要复制数据的起始位置。 ：要复制的字节数。 函数会从源内存地址 复制 个字节的数据到目标内存地址 ，并返回目标内存地址 。 假设存在两片这样的空间由两个指针“dest”和“src”维护，解引用赋值过去相当于copy过去一个字节然后“dest++”和“
C语言之内存函数总结
Poem_coder的博客
01-21 1642
目录 一、内存拷贝函数memcpy(): 二、内存拷贝函数memmove(): 三、内存比较函数memcpy()： 四、内存设置函数memset()： 一、内存拷贝函数memcpy(): void *memcpy( void *dest, const void *src, size_t count ); 1.引用头文件<memory.h> or <string.h> 2.函数memcpy从src的位置开始向后复制count个字节的数据到dest的内存位置。 3...
C语言内存函数超详细讲解
wer24_25的博客
05-18 1317
C语言内存函数超详细讲解,包含memcpy,memmove,memset,memcmp,超详细讲解,小白可以轻松入门.
C语言内存 dump 函数
Murphy
09-18 4921
按照 beyond compare 形式输出内存数据，使用 HEX 方式。 代码如下： #define __is_print(ch) ((unsigned int)((ch) - ' ') < 127u - ' ') void dump_hex(const uint8_t *ptr, uint16_t buflen) { unsigned char *buf = (unsigned ...
C语言动态内存分配函数
ZHA_123的博客
10-06 1828
通讯录大小是100，即最多只能存100个联系人的信息，那如果我们在使用时，需要存200人甚至更多人呢？ 那这个程序就不能满足我们的需求了。 而需要解决这个问题，我们就得学会使用C语言动态内存分配函数，对通讯录的大小进行动态分配。本篇博客会对动态内存分配函数进行讲解，一起来看看吧
C语言-函数的调用
让你爱上电路设计
05-12 1万+
C语言-函数的调用
C语言常用内存函数(超详细版)
m0_65190367的博客
08-25 1443
字符（串）函数可以专门对字符或字符串操作，同时，若要对其他类型数据进行这些操作，就可以借助内存函数直接对内存操作，接下来介绍的几个内存函数就是极其常用的。
c语言’内存清除函数,c语言常用内存处理函数
weixin_29689845的博客
05-22 1780
memset()#includevoid*memset(void*s,int c,size_t n);功能：将s的内存区域的前n个字节以参数c填入(用来初始化)参数：s:需要操作内存s的首地址c:填充的字符，c虽然参数为int,但必须是unsigned char,范围为0-255n:指定需要设置的大小返回值：s的首地址memcpy()#includevoid *memcpy(void *dest,...
【C语言/知识点整理/期末复习】C语言内存函数（附思维导图）
01-23
C语言内存函数详解 在C语言中，内存函数是一组重要的函数，用于操作内存中的数据。这些函数包括memcpy、memmove、memset和memcmp等，都是C语言中最基本的内存操作函数。本文将对这些函数进行详细的介绍和分析。 一...
C语言标准函数库详解.pdf
07-29
头文件提供了一组实用函数，例如：malloc()、free()等，用于实现动态内存分配。头文件提供了一组日期与时间函数，例如：time()函数，用于获取当前时间。 在C语言标准函数库中，还有许多其他的头文件和函数，例如：...
C语言标准函数库速查手册.chm
07-29
C语言的标准函数库，也称为C标准库（C Standard Library），是C语言的核心组成部分，它提供了一系列的预定义函数，方便程序员处理常见的任务，如输入/输出操作、内存管理、字符串处理、数学运算等。 本速查手册...
C语言内存精讲，让你彻底明白C语言的运行机制！
09-12
4. C语言内存对齐，提高寻址效率 5. 内存分页机制，完成虚拟地址的映射 6. 分页机制究竟是如何实现的？ 7. MMU部件以及对内存权限的控制 8. Linux下C语言程序的内存布局（内存模型） 9. Windows下C语言程序的内存...
C 标准库 - ＜ctype.h＞
lly202406的博客
09-27 408
ctype.h>是 C 语言标准库中的一个头文件，它提供了一系列用于测试和操作字符的函数。这些函数主要用于检查字符是否属于特定的字符类别，如字母、数字、标点符号等，以及进行字符的大小写转换。<ctype.h>中的函数通常在处理文本输入时非常有用，例如在用户输入验证或数据格式化中。
深入理解 C 语言中的内存操作函数：memcpy、memmove、memset 和 memcmp
最新发布
w3192285717的博客
10-02 542
在 C 语言中，内存操作函数是非常重要的工具，它们允许我们对内存进行直接操作，从而实现高效的数据处理。memcpymemmovememset和memcmp。通过理解这些函数的工作原理和使用场景，你将能够更好地掌握内存操作的技巧。通过本文的介绍，我们深入了解了memcpymemmovememset和memcmp这四个常用的内存操作函数。这些函数在处理内存数据时非常高效，能够帮助我们实现各种复杂的数据操作。理解这些函数的工作原理和使用场景，将有助于你在实际编程中更好地利用内存操作函数，提升代码的效率和可读性。
四非人的保研之路，2024（2025届）四非计算机的保研经验分享（西南交通、苏大nlp、西电、北邮、山软、山计、电科、厦大等）
小蒋的博客
09-29 1244
本身我就是福建人，xmu 3小时就能到家，然后导这边毕业要求容易，不想读博，达到要求就能放实习，每周打卡35h，比较自由，遂考虑。北邮弱com，联系了蛮多老师，几乎都给了考核机会，面试的老师好几位都考核人工智能基础，会问你卷积的计算，问的还是蛮细的。当时结果是暂定，以为是稳了，遂没联系其他老师，但是之后询问发现只是候补，懒得联系其他老师，928候补到，放弃。东北大学，2000人大机试，入营点送，全国巡回面试，每个人就面不到10分钟，我就被问了3个问题就结束了，候补。科研组，导师有人脉，想读博出成果可以去。
【2024保研经验帖】中科院信工所夏令营经验分享
m0_63002183的博客
09-29 621
中科院信工所夏令营经验分享，信工所夏令营据说只要报了就能进，这个是不是真的尚不清楚，不过qq群里有八九百个人，也属实可怕。招生老师说我们这届夏令营招200-300个左右，于是又开始惶惶不安。 夏令营时期都是线上进行，先是每个科室进行线上招生宣讲，然后报名第一志愿部门和第二志愿部门，不同部门的考核是不同的。有的部门只要求英语面试和综合面试，有的部门除了面试还需要机试，而有的部门除了这些还需要笔试。
C语言malloc函数深度解析
"C语言malloc函数详解，包括相关函数介绍、使用方法、与new的区别以及内存管理要点" 在C语言中，`malloc()`函数是动态内存分配的重要工具，它允许程序在运行时根据需要请求内存。当程序需要创建一个不确定数量的...
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Meiyourou.c

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值