关于程序员:掌握字符与字符串C语言中的神奇函数解析三

✨✨ 欢送大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：C 语言学习
贝蒂的主页：Betty‘s blog

除了字符函数和字符串函数，<string.h> 中还有一类 内存操作函数 ，如 memset()，memcmp() 等函数，他们在性能和某些字符串函数很像，但作用范畴更广，除了作用于字符串外，还能够作用于 int，double 等内置类型，但因为是以字节为单位扭转，所以限度也很大。上面就让咱们来看看吧

申明：void memset(void str, int c, size_t n)

str — 指向要填充的内存块。

c — 要被设置的值。该值以 int 模式传递，然而函数在填充内存块时是应用该值的无符号字符模式。

n — 要被设置为该值的字符数。

作用：复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。

返回值：该值返回一个指向存储区 str 的指针。

memset()函数罕用于初始化

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

输入后果：xxxxxxworld

int main()
{int arr[4] = {1,2,3,4};
    memset(arr, 1, sizeof(arr));
    int i = 0;
    for (i = 0; i < 4; i++)
    {printf("%d", arr[i]);
    }
    return 0;
}

输入后果：16843009 16843009 16843009 16843009

尽管 memset 能够作用于 int，float 等类型，然而 memset 设置是以字节为单位，容易造成不合乎咱们预期的状况。

咱们也能够通过查看内存来验证一下：

思路：memset()函数和 strcpy()函数有点像，都是替换，然而外在实现也有区别，因为 memset()函数还能够用于不同数据类型，所以要先强制类型为(char*)，再以字节为单位替换。

代码实现：

#include <string.h>
#include<assert.h>
void* my_memset(void*str, int c, size_t n)
{assert(str);// 避免 str 为空指针
    char* tmp= (char*)str;// 以字节为单位扭转
    while (n--)
    {
        *tmp = c;
        tmp++;
    }
    return str;
}
int main()
{char str[] = "hello world";
    my_memset(str, 'x', 6);// 以字节为单位
    printf(str);
    return 0;
}

申明：int memcmp(const void str1, const void str2, size_t n)

str1 — 指向内存块的指针。

str2 — 指向内存块的指针。

n — 要被比拟的字节数。

作用：把存储区 str1 和存储区 str2 的前 n 个字节进行比拟。

返回值：

如果返回值 < 0，则示意 str1 小于 str2。

如果返回值 > 0，则示意 str1 大于 str2。

如果返回值 = 0，则示意 str1 等于 str2。

#include <stdio.h>
#include <string.h>
int main() 
{char str1[] = "Hello, World!";
    char str2[] = "Hello, World!";
    char str3[] = "Hello, Betty!";
    // 比拟雷同的字符串
    if (memcmp(str1, str2, strlen(str1)) == 0)
    {printf("str1 和 str2 雷同。\n");
    }
    // 比拟不同的字符串
    if (memcmp(str1, str3, strlen(str1)) != 0) 
    {printf("str1 和 str3 不同。\n");
    }
    return 0;
}

输入：

str1 和 str2 雷同。
str1 和 str3 不同。

思路：总体思路与 strncmp 差不多，只是也须要先强制类型转换

#include<stdio.h>
#include<assert.h>
int my_memcmp(const void* str1, const void* str2, size_t n)
{assert(str1 && str2);//
    char* p1 = (char*)str1;
    char* p2 = (char*)str2;
    while (n--&&(*p1==*p2))
    {if (*p1 == '\0')
        {return 0;}
        p1++;
        p2++;
    }
    return *p1 - *p2;
}

memcmp()函数也是以字节比拟，所以限度也很大

memcmp 是比拟两个存储空间的 前 n 个字节，即便字符串曾经完结，依然要比拟残余的空间，直到比拟完 n 个字节。

strcmp 比拟的是 两个字符串，任一字符串完结，则比拟完结。

strncmp 在 strcmp 的根底上减少比拟个数，其完结条件包含任一字符串完结和比拟完 n 个字节。

strcmp 比拟的 字符串 ，而 memcmp 比拟的是 内存块，strcmp 须要时刻查看是否遇到了字符串完结的 \0 字符，而 memcmp 则齐全不必放心这个问题，所以memcmp 的效率要高于 strcmp

申明：void memcpy(void str1, const void *str2, size_t n)

str1 — 指向用于存储复制内容的指标数组，类型强制转换为 void* 指针。

str2 — 指向要复制的数据源，类型强制转换为 void* 指针。

n — 要被复制的字节数。

作用：从存储区 str2 复制 n 个字节到存储区 str1。

返回值：该函数返回一个指向指标存储区 str1 的指针。

int main()
{int arr1[] = {1,2,3,4,5,6,7,8,9,10};
    int arr2[10] = {0};
    memcpy(arr2, arr1, 20);// 前五个元素
    int i = 0;
    for (i = 0; i < 10; i++)
    {printf("%d", arr2[i]);
    }
    return 0;
}

输入后果：1 2 3 4 5 0 0 0 0 0

思路：天然也是和 strcpy()差不多啦

void* my_memcpy(void* dest, const void* src, size_t n)
{assert(dest && src);// 避免空指针
    void* ret = dest;
    while (n--)
    {*(char*)dest = *(char*)src;
        dest = (char*)dest + 1;
        src = (char*)src + 1;
    }
    return ret;
}

因为 memcpy()函数实现机制，所以不能自己对本人进行拷贝。

memcpy 是从 源存储空间拷贝到指标存储空间 ；而 strcpy，strncpy 是从 源字符串拷贝到指标字符串。

memcpy 拷贝时是依照 参数 n 作为完结标记的，即拷贝 n 个字节就完结；strncpy 是以参数 n 或者 ‘\0’ 为完结标记；strcpy 是判断‘\0’为完结标记。

咱们下面说过 memcpy()无奈对本人进行拷贝，那有没有能对本人拷贝的函数呢，当然有啦，就是咱们的 memmove()函数。

申明：void memmove(void str1, const void *str2, size_t n)

str1 — 指向用于存储复制内容的指标数组，类型强制转换为 void* 指针。

str2 — 指向要复制的数据源，类型强制转换为 void* 指针。

n — 要被复制的字节数。

作用：从 str2 复制 n 个字符到 str1，然而在重叠内存块这方面，memmove() 是比 memcpy() 更平安的办法。如果指标区域和源区域有重叠的话，memmove() 可能保障源串在被笼罩之前将重叠区域的字节拷贝到指标区域中，复制后源区域的内容会被更改。如果指标区域与源区域没有重叠，则和 memcpy() 函数性能雷同。

返回值：该函数返回一个指向指标存储区 str1 的指针。

#include <stdio.h>
#include <string.h>
int main() 
{char str[] = "Hello, World!";
    printf("Original string: %s\n", str);
    // 将字符串前 6 个字符挪动到字符串的开端
    memmove(str, str + 7, 6);
    printf("Modified string: %s\n", str);
    return 0;
}

输入后果：

Original string: Hello, World!
Modified string: World! World!

剖析如下：

状况 1：

// 假如须要拷贝以下场景
int arr1[9] = {1,2,3,4,5,6,7,8,9};
my_memmove(arr1, arr1 + 2, 12);

假如咱们从 3 的地位开始拷贝，3-1,4-2,5-3，拷贝胜利。
假如咱们从 5 的地位开始拷贝，5-3,4-2,5-1，拷贝失败。

状况 2：

// 假如咱们要拷贝的状况如下
int arr1[9] = {1,2,3,4,5,6,7,8,9};
my_memmove(arr1+4, arr1 + 2, 12);

假如咱们从 3 的地位开始拷贝，3-5,4-6,3-7，拷贝失败。
如果咱们从 5 的地位开始拷贝，:5-7,4-6,3-5，拷贝胜利。

状况 3：

int arr1[9] = {1,2,3,4,5,6,7,8,9};
my_memmove(arr1+1, arr1 + 5, 12);
my_memmove(arr1 + 5, arr1 + 1, 12);

假如从 6 开始拷贝，6-2,7-3,8-4，拷贝胜利。
假如从 8 开始拷贝，8-4,7-3,6-2，拷贝胜利。

假如从 2 开始拷贝，2-6,3-7,4-9，拷贝胜利。
假如从 4 开始拷贝，4-8,3-7,2-6，拷贝胜利。

总结：如果 dest 字符串在 src 的字符右边，则从首元素拷贝。如果 dest 字符串在 src 左边，则从开端元素开始拷贝。

代码实现:

void* my_memmove(void* dest, const void* src, size_t n)
{assert(dest && src);// 避免空指针
    void* ret = dest;
    if (dest <= src)//dest 在 src 左侧
    {while (n--)
        {*(char*)dest = *(char*)src;
            dest = (char*)dest + 1;
            src = (char*)src + 1;
        }
    }
    else//dest 在 src 的右侧
    {dest = (char*)dest + n - 1;// 指向开端
        src = (char*)src + n - 1;// 指向开端
        while (n--)
        {*(char*)dest = *(char*)src;
            dest = (char*)dest - 1;
            src = (char*)src - 1;
        }
    }
    return ret;
}

🎈🎈完结撒花🎈🎈

关于程序员:掌握字符与字符串C语言中的神奇函数解析三

1. 简介

2. memset()函数

2.1 用法

2.2 实例

2.3 实现 memset()

3. memcmp()函数

3.1 用法

3.2 实例

3.3 实现 memcmp()

3.4 strcmp，strncmp，memcmp 之间的区别

4. memcpy()函数

4.1 用法

4.2 实例

4.3 实现 memcpy()

4.4 strcpy，strncpy，memcpy 之间的区别

5. memmove()函数

5.1 用法

5.2 实例

5.3 实现 memmove()