1. Toy模板网首页
  2. >Toy博客

＜C语言＞ 字符串内存函数

1年前作者：ikun66666分类：Toy博客阅读(12)违法举报

这篇具有很好参考价值的文章主要介绍了＜C语言＞ 字符串内存函数。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串或者字符数组中。

字符串常量 适用于那些对它不做修改的字符串函数.

注意：字符串函数都需要包含头文件<string.h>

1.长度不受限制的字符串函数

1.1 strlen

strlen()函数用于计算字符串的长度，即字符串中字符的数量，不包括字符串结尾的空字符('\0')。字符串在C语言中是以字符数组的形式表示的，而字符串的结尾总是以空字符('\0')来标识字符串的结束。

strlen()函数的函数原型如下：

size_t strlen(const char *str);

其中，const char *str是一个指向字符数组的指针，表示要计算长度的字符串。size_t是C标准库中定义的无符号整数类型，用于表示数组的大小。

strlen()函数的工作方式是从传入的字符串的开头开始遍历，直到遇到字符串结尾的空字符('\0')为止，并返回遍历过程中经过的字符数量作为字符串的长度。

下面是一个使用strlen()函数的例子：

#include <stdio.h>
#include <string.h>
int main() {
    //a b c d e f \0
    char arr1[] = "abcdef";
    char arr2[] = { 'a','b','c','d' };  //err  随机的数字
    printf("%d\n", strlen(arr1));//6
    printf("%d\n", strlen(arr2));//随机的数字

    return 0;
}

arr2没有以'\0'结尾，strlen()函数会一直遍历直到遇到内存中的第一个空字符为止

注意：

#include <stdio.h>
#include <string.h>
int main() {
    if (strlen("abc") - strlen("abcdef") > 0)//strlen返回的是无符号整型，不会出现负数
        printf(">");
    else
        printf("<");
    return 0;
}

strlen()函数返回的是size_t类型，它是无符号整数类型。因此，不会出现负数。所以输出结果为>

模拟实现strlen

#include <assert.h>
#include <stdio.h>
#include <string.h>
size_t my_strlen(const char *str) {
    assert(str);//str!=NULL
    const char *start = str;
    const char *end = str;
    while (*end != '\0') {
        end++;
    }
    return end - start;
}


int main() {
    char arr[] = "abcdef";
    size_t len = my_strlen(arr);
    printf("%zu\n", len);
    return 0;
}

1.2 strcpy

strcpy()函数用于将一个字符串复制到另一个字符串数组中，包括字符串结尾的空字符('\0')。

strcpy()函数的函数原型如下：

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

其中，char *dest是目标字符串数组的指针，用于存储复制后的字符串；const char *src是源字符串的指针，表示要复制的字符串。

strcpy()函数的工作方式是从源字符串的开头开始，逐个复制字符到目标字符串，直到遇到源字符串的结尾空字符('\0')为止，同时在目标字符串末尾添加一个空字符('\0')来标识复制结束。

需要注意的是，目标字符串数组必须具有足够的空间来存储源字符串，否则可能导致缓冲区溢出，造成程序崩溃或安全漏洞。因此，在使用strcpy()函数时，应该确保目标字符串的长度足够大。

#include <stdio.h>
#include <string.h>
int main() {
    char arr[10] = "xxxxxxxxxx";
    //char arr[3]={ 0 };  //数组空间太小
    //char* p = "hello world"; //err 常量字符串地址
    const char *p = "hello world";
    strcpy(arr, p);    
    printf("%s\n", arr);  //hello world
    return 0;
}

模拟实现strcpy

#include <assert.h>
#include <stdio.h>
#include <string.h>
char *my_strcpy(char *dest, const char *src) {
    assert(dest);//dest！=NULL
    assert(src);
    char *ret = dest;//dest会在下面循环时候改变 所以地址存放在ret中
    while (*dest++ = *src++) {
        //直到\0 赋值过去 表达式为假
        ;
    }

    return ret;
}

int main() {
    char arr1[20] = "abcdefefadw";
    char arr2[] = "hello world";
    printf("%s\n", my_strcpy(arr1, arr2));
    return 0;
}

1.3 strcat

strcat()函数用于将源字符串追加到目标字符串的末尾，包括字符串结尾的空字符('\0')。

strcat()函数的函数原型如下：

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

其中，char *dest是目标字符串数组的指针，表示要将源字符串追加到的目标字符串；const char *src是源字符串的指针，表示要追加的字符串。

strcat()函数的工作方式是从目标字符串的结尾开始，逐个将源字符串中的字符复制到目标字符串末尾，直到遇到源字符串的结尾空字符('\0')。然后，在目标字符串的末尾添加一个空字符('\0')来标识新的字符串结尾。

需要注意的是，目标字符串数组必须具有足够的空间来存储源字符串追加后的结果，否则可能导致缓冲区溢出，造成程序崩溃或安全漏洞。因此，在使用strcat()函数时，应该确保目标字符串的长度足够大。

下面是一个使用strcat()函数的简单例子：

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

int main() {
    char dest[20] = "Hello, ";
    const char *src = "World!";

    strcat(dest, src);

    printf("Concatenated string: %s\n", dest);   //Concatenated string: Hello, World!

    return 0;
}

模拟实现strcat

#include <assert.h>
#include <stdio.h>
#include <string.h>
char *my_strcat(char *dest, const char *src) {
    //1.找目标空间的\0
    char *cur = dest;
    while (*dest != '\0') {
        dest++;
    }
    //2.拷贝源头数据到\0之后的空间
    while (*dest++ = *src++) {
        ;
    }

    return cur;
}

int main() {
    char arr1[20] = "hello \0xxxxx";
    char arr2[] = "world";
    printf("%s\n", my_strcat(arr1, arr2));
    return 0;
}

1.4 strcmp

strcmp()函数用于比较两个字符串，并根据字符串的大小关系返回一个整数值。

strcmp()函数的函数原型如下：

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

其中，const char *str1和const char *str2是两个要比较的字符串的指针。

strcmp()函数的返回值有以下三种情况：

  • 如果str1和str2相等，返回值为0。
  • 如果str1小于str2，返回值为一个负整数（通常为-1）。
  • 如果str1大于str2，返回值为一个正整数（通常为1）。

strcmp()函数会按照字典顺序逐个比较字符串中的字符，直到遇到不同的字符或遇到两个字符串的结尾空字符('\0')为止。比较是按照字符的ASCII码值进行的，因此，字符串中字符的大小关系是按照它们在ASCII码表中的顺序来决定的。

下面是一个使用strcmp()函数的简单例子：

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

int main() {
    const char *str1 = "apple";
    const char *str2 = "banana";

    int result = strcmp(str1, str2);

    if (result < 0) {
        printf("%s is less than %s\n", str1, str2);
    } else if (result > 0) {
        printf("%s is greater than %s\n", str1, str2);
    } else {
        printf("%s is equal to %s\n", str1, str2);
    }

    return 0;
}
//输出结果：apple is less than banana

strcmp()函数将字符串"apple"与字符串"banana"进行比较，因为'a'的ASCII码值比'b'小，所以"apple"被认为是小于"banana"。函数返回一个负整数(-1)，表示str1小于str2。

模拟实现strcmp

#include <stdio.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;   //比较的是ascall码值
}

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "zabcdef";
	int ret = my_strcmp(arr1, arr2);
	if (ret < 0)
		printf("arr1<arr2\n");
	else if (ret > 0)
		printf("arr1>arr2\n");
	else
		printf("arr1==arr2\n");
	return 0;
}

//输出结果：arr1<arr2

2.长度受限制的字符串函数

2.1 strncpy

strncpy()函数用于将源字符串的一部分复制到目标字符串中

strncpy()函数的函数原型如下：

char *strncpy(char *dest, const char *src, size_t n);

其中，char *dest是目标字符串数组的指针，表示要复制到的目标字符串；const char *src是源字符串的指针，表示要复制的字符串；size_t n表示要复制的最大字符数。

strncpy()函数的工作方式是从源字符串的开头开始，逐个将字符复制到目标字符串中，直到复制了n个字符或者遇到源字符串的结尾空字符('\0')为止。如果源字符串的长度小于n，那么目标字符串将在最后添加额外的空字符('\0')来填满n个字符。

需要注意的是，strncpy()函数不保证目标字符串以空字符结尾，如果复制的字符数达到了n，而源字符串还未结束，目标字符串将不会以空字符结尾。因此，在使用strncpy()函数时，应该注意目标字符串是否以空字符结尾。

下面是一个使用strncpy()函数的简单例子：

#include <stdio.h>
#include <string.h>
int main() {
    char arr1[20] = "abcdef";
    char arr2[] = "xxxx";
    strncpy(arr1, arr2, 2);//xxcdef  只拷贝2个字符
    //strncpy(arr1, arr2, 8);  //xxxx
    printf("%s\n", arr1);
    return 0;
}

2.2 strncat

strncat()函数用于将源字符串的前若干个字符追加到目标字符串的末尾

strncat()函数的函数原型如下：

char *strncat(char *dest, const char *src, size_t n);

其中，char *dest是目标字符串数组的指针，表示要将源字符串追加到的目标字符串；const char *src是源字符串的指针，表示要追加的字符串；size_t n表示要追加的最大字符数。

下面是两个使用strncat()函数的简单例子：

#include <stdio.h>
#include <string.h>
int main() {
    char arr1[20] = "abcdef";
    char arr2[] = "xyz";
    strncat(arr1, arr2, 2);//2表示追加2个字符
    printf("%s\n", arr1);  //abcdefxy
    return 0;
}

#include <stdio.h>
#include <string.h>
int main() {
    char arr1[20] = "abc";
    char arr2[] = "xyz";
    strncat(arr1, arr1, 3);//2表示追加2个字符
    printf("%s\n", arr1);  //abcabc
    return 0;
}

2.3 strncmp

strncmp()函数用于比较两个字符串的前若干个字符，根据字符串的大小关系返回一个整数值。

strncmp()函数的函数原型如下：

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

其中，const char *str1和const char *str2是两个要比较的字符串的指针，size_t n表示要比较的字符数。

下面是一个使用strncmp()函数的简单例子：

#include <stdio.h>
#include <string.h>
int main() {
    int ret = strncmp("abcdef", "abc", 3);//3表示比较前三个
    printf("%d\n", ret);                  //0

    ret = strncmp("abcdef", "abc", 4);
    printf("%d\n", ret);//1
    return 0;
}

3.字符串查找函数

3.1 strstr

strstr 是 C 语言中用于在字符串中查找子字符串的函数。

它的函数原型为：

char *strstr(const char *str1, const char *str2);
  • str1：要搜索的主字符串。
  • str2：要查找的子字符串。

函数返回一个指向第一次在 str1 中找到 str2 的指针，如果未找到，则返回 NULL。

下面对 strstr 函数的使用进行详细解释：

示例 1：

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

int main() {
    char str1[] = "Hello, world!";
    char str2[] = "world";

    char *result = strstr(str1, str2);

    if (result != NULL) {
        printf("'%s' is found in '%s'\n", str2, str1);
        printf("Found at position: %ld\n", result - str1);
    } else {
        printf("'%s' is not found in '%s'\n", str2, str1);
    }

    return 0;
}

输出：

'world' is found in 'Hello, world!'
Found at position: 7

示例 2：

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

int main() {
    char str1[] = "I love programming!";
    char str2[] = "Python";

    char *result = strstr(str1, str2);

    if (result != NULL) {
        printf("'%s' is found in '%s'\n", str2, str1);
        printf("Found at position: %ld\n", result - str1);
    } else {
        printf("'%s' is not found in '%s'\n", str2, str1);
    }

    return 0;
}

输出：

'Python' is not found in 'I love programming!'

模拟实现strstr

#include <stdio.h>
char *my_strstr(const char *str1, const char *str2) {
    if (*str2 == '\0') {
        return (char *)str1; // 如果 str2 是空字符串，直接返回 str1 的地址
    }

    while (*str1) {
        const char *temp_str1 = str1;
        const char *temp_str2 = str2;

        // 在 str1 中查找与 str2 相同的子字符串
        while (*temp_str1 && *temp_str2 && (*temp_str1 == *temp_str2)) {
            temp_str1++;
            temp_str2++;
        }

        // 如果找到了完全匹配的子字符串，则返回 str1 的地址
        if (*temp_str2 == '\0') {
            return (char *)str1;
        }

        // 否则，继续在 str1 中寻找下一个可能的匹配位置
        str1++;
    }

    return NULL; // 没有找到匹配的子字符串，返回 NULL
}

int main() {
    char str1[] = "Hello, world!";
    char str2[] = "world";

    char *result = my_strstr(str1, str2);

    if (result != NULL) {
        printf("'%s' is found in '%s'\n", str2, str1);
        printf("Found at position: %ld\n", result - str1);
    } else {
        printf("'%s' is not found in '%s'\n", str2, str1);
    }

    return 0;
}
//'world' is found in 'Hello, world!'

4.字符串拆分函数

4.1 strtok

strtok 是 C 语言中用于将字符串拆分成子字符串的函数。

其函数原型如下：

char *strtok(char *str, const char *delimiters);
  • str：要拆分的字符串，第一次调用时传入要拆分的字符串，在后续调用中设置为 NULL。
  • delimiters：作为分隔符的字符串，用于确定拆分子字符串的位置。

函数返回一个指向拆分后的子字符串的指针。在第一次调用时，函数返回第一个拆分的子字符串，后续调用返回后续的子字符串，直到没有更多的子字符串可供拆分，此时返回 NULL。

示例：

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

int main() {
    char str[] = "apple,banana,orange,grape";

    // 拆分字符串
    char *token = strtok(str, ",");

    while (token != NULL) {
        printf("%s\n", token);
        token = strtok(NULL, ",");
    }

    return 0;
}

模拟实现strtok

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

char *my_strtok(char *str, const char *delimiters) {
    static char *nextToken = NULL; // 用于保存下一个 token 的位置

    if (str != NULL) {
        nextToken = str; // str!=NULL,表示第一次调用，设置初始位置
    }

    if (nextToken == NULL || *nextToken == '\0') {
        return NULL; // 没有更多的 token 可供拆分
    }

    // 跳过开始的分隔符字符
    while (*nextToken && strchr(delimiters, *nextToken)) {
        nextToken++;
    }

    if (*nextToken == '\0') {
        return NULL; // 已到达字符串末尾
    }

    // 找到 token 的起始位置
    char *currentToken = nextToken;

    // 继续查找下一个分隔符位置，将其替换为 NULL 字符
    while (*nextToken && !strchr(delimiters, *nextToken)) {
        nextToken++;
    }

    if (*nextToken) {
        *nextToken = '\0'; // 替换为 NULL 字符
        nextToken++; // 下一个 token 的起始位置
    }

    return currentToken; // 返回当前拆分的 token
}

int main() {
    char str[] = "apple,banana,orange,grape";
    char delimiters[] = ",";

    char *token = my_strtok(str, delimiters);

    while (token != NULL) {
        printf("%s\n", token);
        token = my_strtok(NULL, delimiters);
    }

    return 0;
}

5.错误信息报告函数

5.1 strerror

strerror 用于将错误码（整数）转换为对应的错误消息字符串。该函数通常用于处理与系统调用和库函数相关的错误，将错误码转换为人类可读的错误消息，方便程序员或用户理解和处理错误。

函数原型如下：

char *strerror(int errnum);
  • errnum：要转换的错误码。

函数返回一个指向错误消息字符串的指针。该字符串通常是静态分配的，不应该被修改。因此，最好将返回的字符串复制到另一个缓冲区中，以免被覆盖。

示例：

#include <errno.h>
#include <stdio.h>
#include <string.h>
int main() {
    //strerror的错误码
    //c语言中库函数报错的时候的错误码
    printf("%s\n", strerror(0));//No error
    printf("%s\n", strerror(1));//Operation not permitted
    printf("%s\n", strerror(2));//No such file or directory
    printf("%s\n", strerror(3));//No such process
    printf("%s\n", strerror(4));//Interrupted function call
    return 0;
}

#include <errno.h>
#include <stdio.h>
#include <string.h>
int main() {
    //错误码记录到错误码的变量中
    //errno -  #include<errno.h>  C语言提供的全局的错误变量
    FILE *pf = fopen("test.txt", "r");
    if (pf == NULL) {
        perror("fopen");   //perror = printf+strerror    打印fopen: No such file or directory
        //打印的依然是error变量中错误码对应的错误信息
        printf("%s\n", strerror(errno));//返回了2错误码
        return 1;
    }
    //读文件
    fclose(pf);
    pf = NULL;
    return 0;
}

6.字符操作函数

6.1 字符输入输出函数

getchar和putchar

在 C 语言中，有几个常用的字符输入输出函数，用于读取和输出单个字符。

以下是其中几个常用的字符输入输出函数：

1.getchar 和 putchar 函数：

int getchar(void);
int putchar(int c);
  • getchar 函数用于从标准输入（通常是键盘）读取单个字符，并返回读取的字符的 ASCII 值（作为整数）。
  • putchar 函数用于向标准输出（通常是屏幕）输出单个字符。它的参数是一个整数（字符的 ASCII 值）。

这两个函数可以用来逐个读取和输出字符。例如，可以使用 getchar 来读取用户的输入字符，然后使用putchar 将字符输出到屏幕上。

2.getc 和 putc 函数：

int getc(FILE *stream);
int putc(int c, FILE *stream);
  • getc 函数从指定的文件流 stream 中读取一个字符，并返回读取的字符的 ASCII 值（作为整数）。
  • putc 函数将指定的字符 c 写入到文件流 stream 中。它的参数是一个整数（字符的 ASCII 值）。

这两个函数与 getchar 和 putchar 函数类似，但可以用于从指定文件流中读取或输出字符。

需要注意的是，字符输入输出函数通常在遇到换行符或文件结尾时终止输入。在使用这些函数时，要确保输入输出的字符数量和顺序符合预期，避免因缓冲区问题导致意外行为。

示例：

#include <stdio.h>

int main() {
    int ch;

    printf("Enter a character: ");
    ch = getchar();
    printf("You entered: ");
    putchar(ch);
    printf("\n");

    return 0;
}

6.2 字符分类函数

在 C 语言中，有一组字符分类函数，用于确定字符的属性。这些函数是 ctype.h 头文件中的标准库函数，提供了一系列用于字符分类的工具。

函数 条件
iscntrl 任何控制字符
isspace 空白字符：空格‘ ’，换页‘\f’，换行’\n’，回车‘\r’，制表符’\t’或者垂直制表符’\v’
isdigital 十进制数字 0~9
isxdigital 十六进制数字，包括所有十进制数字，小写字母af，大写字母AF
islower 小写字母a~z
isupper 大写字母A~Z
isalpha 字母az或AZ
isalnum 字母或者数字，az,AZ,0~9
ispunct 标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph 任何图形字符
isprint 任何可打印字符，包括图形字符和空白字符

6.3 字符大小写转换函数

1.tolower 函数：

int tolower(int c);
  • 用于将大写字母转换为相应的小写字母。如果 c 是大写字母，则返回其对应的小写字母；否则，返回原字符 c。

2.toupper 函数：

int toupper(int c);
  • 用于将小写字母转换为相应的大写字母。如果 c 是小写字母，则返回其对应的大写字母；否则，返回原字符 c。

实例1：

int main(){
    char ch = 'w';
    printf("%c\n", toupper(ch)); // toupeer 转换成大写字母 - W
    char ch2 = 'A';
    printf("%c\n", tolower(ch2)); // tolower 转换成小写字母 - a
    return 0;
}

实例2：

#include <ctype.h>
#include <stdio.h>
#include <string.h>
int main() {
    char arr[] = "Are you ok?";
    char *p = arr;
    while (*p) {
        if (islower(*p))//islower 判断是否是小写字母
        {
            *p = toupper(*p);
        }
        p++;
    }
    printf("%s\n", arr);// ARE YOU OK?
    return 0;
}

7.内存函数

7.1 memcpy

memcpy 是用于将内存块的内容从一个位置复制到另一个位置。

其函数原型如下：

void *memcpy(void *dest, const void *src, size_t n);
  • dest：目标内存块的起始地址，表示复制后的数据将存储在这个地址开始的内存块中。
  • src：源内存块的起始地址，表示要复制的数据来源于这个地址开始的内存块。
  • n：要复制的字节数，即要复制的内存块的大小。

函数返回值为 void * 类型，实际上是指向目标内存块的指针，即 dest 的值。

memcpy 函数通过将源内存块中的数据逐字节复制到目标内存块中来实现内存复制。它是一个高效的内存复制函数，通常用于处理字节流或结构体等的复制操作。

实例：文章来源地址https://www.toymoban.com/news/detail-618535.html

#include <stdio.h>
#include <string.h>
int main() {
    int arr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int arr2[10] = {0};
    memcpy(arr2, arr1, 20);// 20表示字节 拷贝5个整型数据

    for (int i = 0; i < sizeof(arr2) / sizeof(int); i++) {
        printf("%d ", arr2[i]);//1 2 3 4 5 0 0 0 0 0
    }
    printf("\n");

    float arr3[] = {1.0f, 2.0f, 3.0f, 4.0f};
    float arr4[] = {0.0};
    memcpy(arr4, arr3, 8);// 8表示拷贝2个浮点型数据

    for (int i = 0; i < sizeof(arr4) / sizeof(float); i++) {
        printf("%f ", arr4[i]);    //1.000000 
    }
    return 0;
}

模拟实现memcpy

#include <assert.h>
#include <stdio.h>
void *my_memcpy(void *dest, void *src, size_t num)//需要传void* 的地址   num的单位是字节
{
    assert(dest && src);
    void *ret = dest;
    while (num--)//交换num次字节的内容 一次交换一次字节
    {
        *(char *) dest = *(char *) src;
        dest = (char *) dest + 1;
        src = (char *) src + 1;
    }
    return ret;
}

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

    }

    printf("\n");

    float arr3[] = {1.0f, 2.0f, 3.0f, 4.0f};
    float arr4[10] = {0.0};
    my_memcpy(arr4, arr3, 8);
    for (i = 0; i < 10; i++) {
        printf("%f ", arr4[i]);    //1.000000 2.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 
    }
    return 0;
}

7.2 memmove

memmove函数与memcpy函数类似，都用于内存拷贝，但它可以处理源内存区域和目标内存区域的重叠情况。memmove函数的函数原型如下：

void* memmove(void* dest, const void* src, size_t n);

它接受三个参数：

  • dest：指向目标内存区域的指针，也就是要将数据拷贝到的位置。
  • src：指向源内存区域的指针，也就是要从中复制数据的位置。
  • n：要复制的字节数。

memmove函数会确保即使源内存区域和目标内存区域有重叠，数据也会正确地被复制。这意味着它比memcpy更安全，因为memcpy在处理重叠内存区域时可能会导致未定义行为。

实例：

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

int main() {
    float arr3[] = {1.0f, 2.0f, 3.0f, 4.0f};
    float arr4[] = {0.0f, 0.0f, 0.0f, 0.0f};
    memmove(arr4, arr3, sizeof(float) * 4);

    for (int i = 0; i < 4; i++) {
        printf("%f ", arr4[i]); // 输出: 1.000000 2.000000 3.000000 4.000000
    }

    return 0;
}

注意：

memcpy只需要实现不重叠的拷贝就可以了 VS中的memcpy和mommove实现方式差不多 可以替代

memmove是需要实现重叠内存的拷贝

模拟实现memmove

#include <assert.h>
#include <stdio.h>
#include <string.h>
void *my_memmove(void *dest, void *src, size_t num)//需要传void* 的地址   num的单位是字节
{
    assert(dest && src);
    void *ret = dest;
    if (dest < src) {
        while (num--)//交换num次字节的内容 一次交换一次字节
        {
            *(char *) dest = *(char *) src;
            dest = (char *) dest + 1;
            src = (char *) src + 1;
        }
    } else {
        while (num--) {
            *((char *) dest + num) = *((char *) src + num);//后面的数据 换到前面的数
        }
    }

    return ret;
}

int main() {
    float arr3[] = {1.0f, 2.0f, 3.0f, 4.0f};
    float arr4[] = {0.0f, 0.0f, 0.0f, 0.0f};
    my_memmove(arr4, arr3, sizeof(float) * 4);

    for (int i = 0; i < 4; i++) {
        printf("%f ", arr4[i]);// 输出: 1.000000 2.000000 3.000000 4.000000
    }

    return 0;
}

7.3 memcmp

memcmp用于比较两个内存区域的内容是否相等。

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

memcmp函数接受三个参数：

  • ptr1：指向要比较的第一个内存区域的指针。
  • ptr2：指向要比较的第二个内存区域的指针。
  • num：要比较的字节数。

memcmp函数将会按字节逐个比较两个内存区域中的数据，直到比较完指定的字节数num或者遇到不相等的字节为止。如果两个内存区域的数据完全相等，则memcmp函数返回0。如果两个内存区域的数据不相等，则返回一个小于0的值或者大于0的值，其数值大小取决于第一个不相等的字节的差值。

下面是一个简单的例子：

#include <stdio.h>
#include <string.h>
int main(){
    int arr1[] = { 1,2,3,4,5 }; //01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00
    int arr2[] = { 1,2,3,0,0 }; //01 00 00 00 02 00 00 00 03 00 00 00 00 00 00 00
    int ret = memcmp(arr1, arr2, 12);    //前12字节的内存
    printf("%d\n", ret); //0  

    ret = memcmp(arr1, arr2, 13);   //前13字节的内存
    printf("%d\n", ret);  //1
    return 0;
}

模拟实现memcmp

int my_memcmp(const void* ptr1, const void* ptr2, size_t num) {
    const unsigned char* byte_ptr1 = (const unsigned char*)ptr1;
    const unsigned char* byte_ptr2 = (const unsigned char*)ptr2;

    for (size_t i = 0; i < num; i++) {
        if (byte_ptr1[i] < byte_ptr2[i]) {
            return -1;
        } else if (byte_ptr1[i] > byte_ptr2[i]) {
            return 1;
        }
    }

    return 0;
}

7.4 memset

memset函数用于将指定的内存区域设置为特定的值。

其函数原型如下：

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

memset函数接受三个参数：

  • ptr：指向要设置的内存区域的指针。
  • value：要设置的值，通常以整数形式传递，但实际上会被转换为unsigned char类型。
  • num：要设置的字节数。

memset函数会将指定内存区域的每个字节都设置为value指定的值，重复num次。它通常用于对数组或结构体进行初始化，也可用于将内存区域置零。

实例：

#include <stdio.h>
#include <string.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    memset(arr, 0, 8);//8个字节
    int i = 0;
    for (i = 0; i < 5; i++) {
        printf("%d ", arr[i]);// 0 0 3 4 5
    }
    return 0;
}

模拟实现memset

void* my_memset(void* ptr, int value, size_t num) {
    unsigned char* byte_ptr = (unsigned char*)ptr;
    unsigned char byte_value = (unsigned char)value;

    for (size_t i = 0; i < num; i++) {
        byte_ptr[i] = byte_value;
    }

    return ptr;
}

到了这里，关于＜C语言＞ 字符串内存函数的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包赞助服务器费用

相关文章

  • 【C语言】字符函数与字符串函数以及内存函数 { 超详细攻略，一篇学会 }

    【C语言】字符函数与字符串函数以及内存函数 { 超详细攻略，一篇学会 }

    今日分享：字符、字符串函数和内存函数 内存函数 就是对内存进行操作的函数 字符串函数 就是对字符串进行操作的函数 字符函数 就是对字符进行操作的函数 str 前缀的函数是字符串函数，头文件string.h mem 前缀的函数是内存函数，头文件stdlib.h 字符分类函数包含在 ctype.h 头

    2024年03月18日
    浏览(17)
  • C语言之字符串,内存操作函数详解(一)

    C语言之字符串,内存操作函数详解(一)

    💓博主CSDN主页:杭电码农-NEO💓   ⏩专栏分类:C语言学习分享⏪   🚚代码仓库:NEO的学习日记🚚   🌹关注我🫵带你学习更多C语言知识   🔝🔝 C语言的标准库为我们提供了丰富的字符串操作函数与内存操作函数,有我们熟悉的 strlen ,strcpy ,也有我们不熟悉的 strchr , strstr 等

    2024年02月08日
    浏览(19)
  • 【c语言：常用字符串函数与内存函数的使用与实现】

    【c语言：常用字符串函数与内存函数的使用与实现】

    简介：本篇文章是对C语言中常用的字符串函数和内存函数的学习以及模拟实现 文档内容来自：https://legacy.cplusplus.com/ 字符串以 ‘\\0’ 作为结束标志， strlen函数返回的是在字符串中 ‘\\0’ 前⾯出现的字符个数（ 不包含 \\\'\\0\\\' )。 参数指向的字符串必须要以 ‘\\0’ 结束。 注意函

    2024年02月04日
    浏览(12)
  • 一篇博客学会系列（1） —— C语言中所有字符串函数以及内存函数的使用和注意事项

    一篇博客学会系列（1） —— C语言中所有字符串函数以及内存函数的使用和注意事项

    目录 1、求字符串长度函数 1.1、strlen 2、字符串拷贝(cpy)、拼接(cat)、比较(cmp)函数 2.1、长度不受限制的字符串函数 2.1.1、strcpy 2.1.2、strcat 2.1.3、strcmp 2.2、长度受限制的字符串函数 2.2.1、strncpy 2.2.2、strncat 2.2.3、strncmp 3、字符串查找函数 3.1、strstr 3.2、strtok 4、错误信息报告函数

    2024年02月08日
    浏览(11)
  • 字符串函数+内存函数（详解）

    字符串函数+内存函数（详解）

    本期带大家一起来学习字符串函数+内存函数😀 😃 😄 1. 求字符串长度 strlen🚀🚀 字符串 已经 ‘\\0’ 作为结束标志 ，strlen函数返回的是在字符串中 ‘\\0’ 前面出现的字符个数（不包含 ‘\\0’ )。 strlen在库里面的参数是如此的 ⌛️⌛️ 接下来我们来模拟实现strlen ，接下来

    2023年04月17日
    浏览(18)
  • 字符串函数和内存操作函数

    字符串函数和内存操作函数

    目录 0.字符串回顾 1.函数介绍 1.1 strlen 1.2 strcpy 1.3 strcat 1.4 strcmp 1.5 strncpy 1.6 strncat 1.7 strncmp 1.8 strstr 1.9 strtok 1.10 strerror 1.11 memcpy 1.12 memmove 1.13 memcmp 1.14 memset 1.15 字符相关函数 字符分类函数 字符转换函数 2.函数模拟实现 2.1模拟实现strlen 2.2模拟实现strcpy 2.3模拟实现strcat 2.4模拟

    2024年02月15日
    浏览(15)
  • 字符串函数和内存函数详解（2）

    字符串函数和内存函数详解（2）

    🐵本文会将会对剩余的 字符串库函数 和 内存函数 进行讲解 strstr函数原型： strstr用于在字符串中找子串，strstr会返回str1中出现str2的起始地址，如果在str1中没有找到str2，则返回空指针 strstr会返回arr1中第一次出现arr2的地址，这里就是\\\'l\\\'的地址，将其传给指针ret，在打印时

    2024年02月07日
    浏览(16)
  • 字符串和内存函数（2）

    字符串和内存函数（2）

    2.13 memcpy void* memcpy(void* destination, const void* source, size_t num); 函数memcpy从source的位置开始向后复制num个 字节 的数据到destination的内存位置。 这个函数在遇到 ‘\\0’ 的时候并不会停下来。 如果source和destination有任何的重叠，复制的结果都是未定义的。 memcpy是内存拷贝，它可以拷

    2024年02月04日
    浏览(10)
  • 【C】字符串函数和内存函数的介绍

    【C】字符串函数和内存函数的介绍

    strlen size_t strlen ( const char * str ); 字符串已经 ‘\\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\\0’ 前面出现的字符个数（不包含 ‘\\0’ )。 参数指向的字符串必须要以 ‘\\0’ 结束。 注意函数的返回值为size_t，是无符号的（ 易错 ） 代码演示： 运行结果： strcpy char* s

    2024年02月16日
    浏览(11)
  • C/C++字符函数和字符串函数详解————内存函数详解与模拟

    C/C++字符函数和字符串函数详解————内存函数详解与模拟

    个人主页：点我进入主页 专栏分类：C语言初阶      C语言程序设计————KTV       C语言小游戏     C语言进阶 C语言刷题 欢迎大家点赞，评论，收藏。 一起努力，一起奔赴大厂。 目录 1.前言 2 .memcpy函数 3.memmove函数 4.memset函数  5.memcmp函数            前面学习了关

    2024年02月08日
    浏览(13)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包