字符和字符串的库函数模拟与实现

已于 2023-11-19 16:19:06 修改
阅读量1k 收藏 44
点赞数 54
分类专栏： C语言 文章标签： 算法 c语言
于 2023-09-01 20:22:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74967884/article/details/132494232
版权

前言：

相信大家平常在写代码的时候，用代码解决实际问题时苦于某种功能的实现，而望而止步，这个时候库函数的好处就体现出来了，当然个人代码编写能力强的可以自己创建一个函数，不过相当于库函数来说却是浪费了一点时间，库函数的准确性和有效性对我们的好处就显而易见了。本次重点是着重介绍字符函数和字符串函数的模拟和实现

本章重点知识点：

（1）求字符串长度

          strlen

（2）长度不受限制的字符串函数    

          strcpy
          strcat
          strcmp

（3）长度受限制的字符串函数介

          strncpy
          strncat
          strncmp
（4） 字符串查找
          strstr
          strtok
（5） 错误信息报告
          strerror
（6） 字符操作
（7）内存操作函数
          memcpy
          memmove
          memcmp
          memset

1、函数的介绍

1.1 strlen函数

 size_t strlen (const char *str);

头文件名：#include<string.h>

size_t 是表示无符号整数的意思，也就相当于unsigned int 。

实际用法：

#include<stdio.h>
int main()
{
    char arr1[] = "abcdef";
    int net = strlen(arr1);

    printf("%d", net) ;
    return 0;
}

 众所周知字符串以'\0'为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包 含 '\0' )。

1.2  strcpy函数

 char *strcpy (char *destination,  const  char  *source)

头文件名：#include<string.h>

const函数用来限制 *source，也就是指针*source 不能随意改变数据。

比如：

int main()
{
    int b = 10;
    int* p = &b;
    *p = 6;
    return 0;
}

此时*p在没有const函数修饰的情况下*p可以随意更改所指的数据大小 。

int main()
{
    int b = 10;
    const int* p = &b;
    *p = 6;
    return 0;
}

而现在*p有了const函数修饰,现在运行程序就会报错。

所以该函数的用法就知道了，用指针*source所指向地址的数据复制到指针*destination中。

下面来看strcpy函数实际用法：

#include<stdio.h>
#include<string.h>
int main()
{
    char  arr1[20] = { 0 };
    char  arr2[20] = "abcdefgh";
    strcpy(arr1, arr2);
    printf("%s", arr1);
    return 0;
}

为了arr2中能够完全的存放下arr1中的数据，所以arr2的空间与arr1一致，当然在arr2创建的空间足够大的前提下 arr[20]也可以变成这样写arr[],这样也是符合语法标准。

1.3 strcat函数

char *strcat (char *destination,  const  char *source)

头文件名：#include<string.h>

const函数的用法在介绍strcpy函数时就已经讲到了对于还不太清楚的伙伴可以往上翻一下，了解明白，在此后就不做过多解释了。

此次strcat函数里的参数和strcpy函数里的参数的内容大致相同，不过用法确实大不相同。

从第一个图中几个关键词：来源，目的，串联等，应该不难想到，该函数应该是把后面字符串的内容连接到第一个 字符串后面。

实际应用：

#include<stdio.h>
#include<string.h>
int main()
{
    char arr1[20000] = "abcdef";
    char arr2[20] = "yangyang";
    strcat(arr1, arr2);
    printf("%s", arr1);
    return 0;
}

 运行后该函数的用法和我们所猜的差不多。在程序中，因为是把第二个字符串连接到第一个 字符串中，所以第一个字符串数组的空间必须大，所以我才给了arr1这么大的空间，当然在保证了第一个字符串数组足够大的情况下，arr2[20]也可以写成arr2[]。

1.4 strcmp函数

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

头文件名：#include<string.h>

此函数较前几个函数还是有很大不同，光两个参数就不能随意改变，而且返回值有很大区别，上面函数的函数返回值大多都是void型，而此函数的返回值是int型。根据图中的意思，该函数是一个比较两个字符串大小的函数。如果两个字符串相等就返回0，如果是第一个字符串大于第二个字符串就返回大于0的整数，反之就会返回小于0的数。在比较时前提是所比较的字符必须表示同一个大小，不然即使多，但实际比出来也是小。

实际应用：

#include<stdio.h>
int main()
{
    char  arr1[] = "abcdefgh";
    char  arr2[] = "abcdefghgdhs";

    char  abb1[] = "abcdef";
    char  abb2[] = "abc";

    char  acc1[] = "abcdef";
    char  acc2[] = "abcdef";

    int num1 = strcmp(arr1, arr2);
    int num2 = strcmp(abb1, abb2);
    int num3 = strcmp(acc1, acc2);

    printf("num1 = %d\nnum2 = %d\nnum3 = %d\n", num1, num2, num3);
    return 0;
}

 相信有了这个strcmp函数，大家在平常计算字符串长度会更加方便。

1.5 strncpy函数

 char *strncpy(char  *destinnation,  const  char  *source, size_t  num)

头文件名：#include<string.h>

size_t是无符号整型，而根据图中的解释这个函数仅仅比strcpy函数多了第二个字符串可以指定多少字节的字符来复制在第一个字符串中的功能。

实际应用1：

#include<stdio.h>
#include<string.h>
int main()
{
    char  arr1[2000] = { 0 };
    char arr2[] = "abcdef";

    strncpy(arr1, arr2, 5);

    printf("%s\n", arr1);
    return 0;
}

 此函数比strcpy用的范围更大，更适应如今变化多端的局面。

1.6 strncat函数

 char  *strncat  (char  *destination,  const  char  *source,  size_t  num)

 头文件名：#include<string.h>

此函数也比strcat函数多了第二个字符串可以指定多少字符连接在第一个字符串的后面的功能其它大体都是相同。

实际应用：

#include<stdio.h>
#include<string.h>
int main()
{
    char  arr1[2000] = "abcd";
    char  arr2[] = "abcdefgh";

    strncat(arr1, arr2, 4);

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

    return 0;
}

 更方便大家的使用。


1.7 strncmp函数

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

 头文件名：#include<string.h>

 此函数较strcmp函数也只是多了可以指定用多少字节的字符来比较的功能，其它的大体相同。比上面几个函数有点不同，此函数的后面的数字是作用于两个字符串，而不仅仅作用于第二个字符串了。

实际应用：

#include<stdio.h>
#include<string.h>
int main()
{
    char  arr1[] = "abcd";
    char  arr2[] = "abcdefgh";

    char  arr3[] = "abcdef";
    char  arr4[] = "abcd";

    int num1 = strncmp(arr1, arr2, 2);
    int num2 = strncmp(arr1, arr2, 6);
    int num3 = strncmp(arr1, arr2, 4);
    int num4 = strncmp(arr3, arr4, 6);

    printf("num1 = %d\nnum2 = %d\nnum3 = %d\n", num1, num2, num3);


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


    return 0;
}

 多出的功能也只是为了方便使用，更灵活。

1.8 strstr函数

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

 头文件名：#include<string.h>

根据图中的意思，此函数大概就是寻找子函数，并打印子函数及其后面的内容，返回值也是char *指针。

实际应用：

#include<stdio.h>
#include<string.h>
int main()
{
    char arr1[20] = "abcdefgh";
    char arr2[20] = "de";

    char *str = strstr(arr1, arr2);

    printf("%s\n", str);
    return 0; 
}

1.9 strtok函数

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

 头文件名：#include<string.h>

此函数的参数和strstr函数的参数大致相同表达的意思有些许的差别，由const函数可知该函数的第二个参数是不能变，而图中拆分字样，那第一个参数应该是等同于标识符，把第二个参数分成多组字符然后再打，分隔符的顺序是没有讲究的，随便放就可以。

sep参数是个字符串，定义了用作分隔符的字符集合

第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标 记。

strtok 函数找到 str 中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：
strtok 函数会改变被操作的字符串，所以在使用 strtok 函数切分的字符串一般都是临时拷贝的内容
并且可修改。）
strtok 函数的第一个参数不为 NULL ，函数将找到 str 中第一个标记， strtok 函数将保存它在字符串
中的位置。
strtok 函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标
记。
如果字符串中不存在更多的标记，则返回 NULL 指针。

实际应用：

#include<stdio.h>
#include<string.h>
int main()
{
    char arr1[20] = "abc@def、jkm.klj";
    char arr2[10] = "@、.";
    char coop[20] = { 0 };
    strcpy(coop, arr1);
    char* str = NULL;
    for (str = strtok(coop, arr2); str != NULL; str = strtok(NULL, arr2))
    {
        printf("%s\n", str);
    }
    return 0;
}

 上面那段for循环那段函数可有有些人看不懂，它可以还可以替换成：

    str = strtok(coop, arr2);
    printf("%s\n", str);

    str = strtok(NULL, arr2);
    printf("%s\n", str);

    str = strtok(NULL, arr2);
    printf("%s\n", str);

    str = strtok(NULL, arr2);
    printf("%s\n", str);

两种写法是表达一样的意思。

1.10 strerror函数

 char  *strerror(int errnum )

 头文件名：#include<string.h>

根据图中的意思，这个函数大概就是：返回错误码，所对应的错误信息。

实际应用：

#include <stdio.h>
#include <string.h>
int main ()
{
 FILE * pFile;
 pFile = fopen ("unexist.ent","r");
 if (pFile == NULL)
   printf ("Error opening file unexist.ent: %s\n",strerror(errno));
   //errno: Last error number
 return 0;
}

1.11  memcpy函数

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

 头文件名：#include<string.h>

 虽然此函数也是复制函数但是较前面几个函数不同，这是内存函数。由它是void型就大致知道，大部分结构都能复制，比较灵活。也能指定多少数据复制，只不过第三个参数是以字节为单位

实际应用：

#include<stdio.h>
#include<string.h>
int main()
{
    int abb1[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int abb2[20] = { 0 };

    char arr1[10] = "abcdefghi";
    char arr2[20] = { 0 };

    memcpy(abb2, abb1, 20);
    memcpy(arr2, arr1, 20);

    int i = 0;
    for (i = 0; i < 20; i++)
    {
        printf("%d ", abb2[i]);
    }
    printf("\n");

    printf("%s\n", arr2);
    return 0;
}

 从上图中可知当空间过剩时会用0来补上，而当是字符串传递时就不会，如下图：

1.12 memmove函数

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

 头文件名：#include<string.h>

此函数和memcpy函数功能大体相同，memmove可以说成是memcpy的子集，memcpy只能复制两个来自不同空间，不能有所重叠。而memmove函数它可以复制同一个空间的值，可以重叠，它后面第三个参数也是以字节为单位。

实际应用：

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

1.13 memcmp函数

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

 头文件名： #include<string.h>
由图中所介绍的意思可知，该函数与strncmp函数有异曲同工之妙，只是该函数可比较的范围更大，并不仅仅只是比较字符串，同样它也是一个内存函数。
实际应用：

#include<stdio.h>
#include<string.h>
int main()
{
    char  arr1[20] = "abcdefgh";
    char  arr2[20] = "abcdef";
    //因为该指定的字节是作用于两个参数，故只能比较相等时或者另一个大于另一个，而不能比较小的时候的大小
    int num1 = memcmp(arr1, arr2, 20);
    int num2 = memcmp(arr1, arr2, 2);

    printf("num1 = %d\n", num1);
    printf("num2 = %d\n", num2);

    return 0;
}

1.14 memset函数

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

 头文件名：#include<string.h>

由图中表达的意思，这就是一个填充函数，也就是用第二个int型参数，再根据第三个参数所制定的字节数，从而把in型参数填充到第一个参数中。

实际应用：

#include<stdio.h>
#include<string.h>
int main()
{
    char  arr1[20] = "abcdefgh";
    memset(arr1, '0', 8);
    printf("%s\n", arr1);
    return 0;
}

 库函数的讲解就讲解在此，希望大家能有所收获。

2、库函数的模拟实现

2.1  模拟实现strlen函数

第一种方法：使用了临时变量。利用临时变量来计数，最后返回临时变量的值即可。

int my_strlen(char* arr)
{
    int count = 0;
    while (*arr++ != '\0')
    {
        count++;
    }
    return count;
}

第二种方法：不使用临时变量（递归）。使用递归也是过程最简单的。

int my_strlen(char* arr)
{
    if (*arr == '\0')
        return 0;
    else return 1 + my_strlen(arr + 1);
}

第三种方法：使用两个指针。利用指针与指针之间的距离长度来算字符的大小。

int my_strlen(char* arr)
{
    char* p = arr;
    while (*p != '\0')
        p++;
    return p - arr;

}

2.2 模拟实现strcpy

第一种写法：是利用字符串以‘\0’为结束标志的特性，来依次把值存过去。

void my_strcpy(char* arr, char* aee)
{
    while (*aee != '\0')
    {
        *arr = *aee;
        arr++;
        aee++;
    }
}

另一种写法：这种写法相较于传统的写法有很大不同，是直接构造char*的函数，首先利用一个指针来记录目的指针的初始位置，在利用另一个带有目的数据的指针来传入目的指针里，最后再传回用来记录目的指针的初始位置指针。

char * my_strcpy(char* arr, char* aee)
{
    char* net = arr;
    while (*arr++ = *aee++)
    {
        ;
    }
    return net;
}

2.3模拟实现strcat函数

该方法是利用了指针与字符串的特性。

void my_strcat(char* arr1, char* arr2)
{
    while (*arr1)
    arr1++    ;

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

2.4 模拟实现strcmp函数

int my_strcmp(char* arr1, char* arr2)
{
    while (*arr1 == *arr2)
    {
        if (*arr1 = '\0')
            return 0;
        arr1++;
        arr2++;
    }
    if (*arr1 > *arr2)
        return 1;
    else return -1;
}

2.5 模拟实现strstr函数 

首先利用s1、s2、cp三个指针进行辅助

char* my_strstr(char* str1, char* str2)
{
    char* cp = str1;
    char* s1 = cp;
    char* s2 = str2;
    while (*cp)
    {
        s1 = cp; 
        s2 = str2;
        while (*s1 && *s2 && *s1 == *s2)
        {
            s1++;
            s2++;
        }
        if (*s2 == '\0')
            return cp;
        cp++;
    }

}

首先用cp标记str1的初始位置，然后用s1标记cp的位置，利用循环找到s1和s2相同的地方，再判断是否s2中的数据在s1中能够找到。如果找到，s2就会为‘\0’，从而结束循环，返回cp即可。如果s2中的数据不能在s1中全部找到，那么cp就继续移动到下一位直到移动到'\0'结束程序。此过程可能有点繁琐，需要大家仔细、用心的去感悟和理解。

2.6 模拟实现memcpy函数

void my_memcpy(void* arr1,const void* arr2, int se)
{
    char* ret = arr1;
    while (se)
    {
        *(char*)arr1 = *(char*)arr2;
        arr1 = (char*)arr1 + 1;
        arr2 = (char*)arr2 + 1;
        se--;
    }
    return ret;
 

首先我们需要用一个指针来记录目标函数的起始位置。为什么要记录呢？也就是为了我们最后返回去，不然我们操作完目标函数的指针的位置不在起始位置。

关于为什么要这样写 ：

 arr1 = (char*)arr1 + 1;
 arr2 = (char*)arr2 + 1;

而不是这样写：

arr1++;

arr2++;

这是因为当初创建my_memcpy函数时我们为了瞒住各种数据的需求，就用void型，而在void型中arr1++和arr2这样写就是错误的，系统不知道你是什么类型，它怎么知道加多少呢也就是会造成系统错误。

可能有的人会说不是在上一步已经进行了强制数据转换了吗，而我要说的是强制数据转换只是在那一个过程转换了，而在下一个过程它有又会失效，不信的话你们可以去试试，我就不作过多的解释。

2.7 模拟实现memmove函数

void *my_memmove( void* dest,const void* trst, int se)
{
    void* ret = dest;
    if (dest < trst)
    {
        while (se--)
        {
            *((char*)dest) = *(char*)trst;
            dest = (char*)dest + 1;
            trst = (char*)trst + 1;
            
        }
    }
    else
    {
        while (se--)
        {
            *((char*)dest + se) = *((char*)trst + se);
            
        }
    }
    return ret;
}

此函数模拟的难度应该就在于为什么要判断。这个总共分为两种情况，第一种情况是dest在trst前面时，只能从前面传入数据才能正确表达，也就是在执行函数时这样的表达：

my_memmove(arr1,  arr1+2,  8);

也就是此种情况。

而第二种情况就是dest在trst的后面时，只能从后面开始传入数据才能正确表达，也就是在执行函数时这样的表达：

my_memmove(arr1 + 2,  arr1,  8);

两种表达的意思在代码运行时是两种情况。

我们先来讲讲第一种情况：dest在trst的前面看能不能从后面开始传入数据：

按照常规就是把trst中的数据依次放在dest中也就是6放在dest中4的位置，然后trst中的5放在dest中3的位置，相信此时大家已经看出来了由于dest和trst都是指针，它们中数据的改变会影响目标函数，此时由于之前的移动原本trst中还没有传过去的3和4已经被5和6给代替了，所以如果继续传的话大概率是5和6一直交替。

而相反如果从前面开始传入就不会覆盖数据，大家可以试一试。

第二种情况也就是这样的一个过程，大家可以仔细想一想其中的逻辑关系或者在纸上画一下感受一下。

感谢语

字符和字符串的库函数模拟与实现，在这里也就讲完了，由于我自己的知识水平，可能在某些方面讲的不是那么通俗易懂，有些知识讲的不是很完整，大家多多包容包容，再次感谢大家的观看，谢谢！

我们一起加油 GO GO GO ！

悦心无谓
关注
  • 54
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 47
    评论
专栏目录
字符函数与字符串函数模拟
weixin_52142420的博客
08-02 61
文章目录前言一、字符函数strtokstrerror字符分类函数memcpymemmovememcmp二、字符函数模拟strlen模拟strcpy模拟strcat模拟strcmp模拟strstr模拟memcpy模拟memmove函数模拟 前言 提示：在上一节中，我们已经介绍了一些字符函数并了解了其功能。接下来，我们便讨论剩余的字符串函数，便通过模拟实现函数加深印象。 提示：以下是本篇文章正文内容，下面案例可供参考 一、字符函数 strtok char * strtok ( char * str, con
字符串库函数的模拟实现
weixin_45511964的博客
08-27 115
1.strcpy（字符串拷贝） strcpy(arr,str):arr是要拷贝的空间，str是要被拷贝的字符串。 #include <stdio.h> #include <assert.h> char* my_strcpy(char*dest,const char*str) { char* ret = dest;//保存dest初始位置 assert(dest&...
字符串strlen库函数模拟实现
波风水门的博客
12-28 118
第一次尝试 #include<stdio.h> #include<stdlib.h> size_t myStrlen(const char* str) { if (str == NULL) { return NULL; } size_t ret = 0; while (*str != '\0') { str++; ret++; } return ret; } int main() {
详细介绍五种常用字符串库函数 以及对库函数的模拟实现
记录并分享学习编程时的知识点...
09-21 1117
本文介绍了strlen.strcpy.strcmp.strcat.strstr五大字符串库函数及使用自定义函数模拟实现这五个字符串库函数.学会使用字符串库函数,在处理字符串时会事半功倍...
c++实现的字符串程序
08-22
6. **内存管理**: 自定义字符串类可能涉及到动态内存分配和释放，以模拟`std::string`的动态特性。这需要理解指针、动态内存分配（如`new`和`delete`操作符）以及防止内存泄漏的重要性。 7. **C++标准库函数**: ...
STM8 模拟串口 IO口模拟
03-18
在实践过程中，可以参考ST官方提供的AN2781应用笔记，该文档详细介绍了STM8模拟串口的实现步骤、代码示例以及注意事项，有助于快速理解和实现这一功能。 总的来说，STM8的IO口模拟串口功能是一项实用的技巧，尤其在...
LCD输出字符串
02-18
下面将详细讲解如何在C语言环境中实现LCD输出字符串。 首先，我们需要理解LCD的工作原理。LCD显示屏通常由多个像素点组成，每个像素点可以通过控制电流来改变颜色或透明度。在嵌入式系统中，我们通过GPIO（General ...
最新单片机仿真 单片机向主机发送字符串.rar
06-10
本资源"最新单片机仿真 单片机向主机发送字符串.rar"显然与单片机编程和通信有关，特别是涉及单片机如何向主机（如个人电脑）发送数据，这通常通过串行通信协议实现。以下是关于这个主题的详细知识点： 1. **单片机...
cubemx实现串口printf重定向自动打印
11-01
1. **定义串口输出函数**：创建一个函数，如`HAL_UART_Printf`，接收一个格式化字符串和变量参数列表，类似于标准库的`printf`。该函数内部调用`HAL_UART_Transmit`发送字符，直到所有字符都发送完毕。 2. **替换...
算法-KMP字符串匹配
xx_xb的博客
07-23 229
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
算法题目整合5
qq_62571233的博客
07-23 878
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 276
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
【常微分方程】
qq_74285286的博客
07-24 300
常微分方程笔记
AtCoder Beginner Contest 363(A~D题)
sin1810335764的博客
07-23 218
枚举长度，首先计算出答案回文数的长度。通过枚举和减法可以计算出是当前长度下第k𝑘大的回文数。而前一半就是顺序的，第k𝑘大就是当前长度的数的第k𝑘大，这个很好求。接下来只需要构成回文，直接输出即可。将L𝐿从小往大排序，那么只需要第n−P+1𝑛−𝑃+1大的数满足条件即可，假设这个数是a𝑎。因此，只需要计算T−a𝑇−𝑎即可。注意，如果这个数是负数，意味着初始时就满足条件，此时要输出00。我们只需要找到下一阶段的下限。a / 100 是本阶段+1 变成下一阶段，再 * 100变成下限，再与原来的相减即可。
算法：BFS解决 FloodFill 算法
一名还在努力学习技术的程序员的博客
07-24 1065
本篇博客是关于BFS 解决 FloodFill 算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
三维点云中常用的表面重建算法
Argulo的博客
07-22 1334
表面重建算法起源于计算机视觉和计算几何学领域。早期的研究集中在从二维图像中提取三维信息。然而，随着三维扫描技术的进步，越来越多的研究转向了如何从点云数据中重建表面。三维点云表面重建技术的发展，始于20世纪90年代，主要推动力是激光扫描和结构光扫描的广泛应用。
2024.7.24 作业
最新发布
qq_64434282的博客
07-24 1063
【代码】2024.7.24 作业。
Java实现七大排序（二）
lllsure的博客
07-23 541
冒泡排序、快速排序、归并排序
模拟实现库函数strcpy
07-27
你可以使用以下代码模拟实现库函数strcpy： ```c #include char* strcpy(char* dest, const char* src) { char* p = dest; while (*src) { *dest++ = *src++; } *dest = '\0'; return p; } int main() { ...
评论 47
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

悦心无谓

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

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

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

打赏作者

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

抵扣说明：

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

余额充值