strerror函数，strtok函数，内存操作函数＜/u＞ 1.memcpy 2.memmove 3.memcmp 4memesct 及模拟实现

strerror函数，strtok函数，内存操作函数 1.memcpy 2.memmove 3.memcmp 4memesct 及模拟实现

***<一>strtok函数***

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

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

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

◼strtok函数找到str中的一个标记并将其用**\0**结尾，返回一个指向这个标记的指针（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时和拷贝的内容平且可修改。）

◼strtok函数的第一个参数不为NULL，函数将找到str中的第一个标记，strtok函数将保存他在字符串中的位置。

◼strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置之开始，查找下一个标记。

◼如果字符中不存在更多的标记，则返回NULL指针。

strtok用法介绍

#include<stdio.h>
    
    
int main()
{
    char arr[]="wangxiaoming@yeah.net";
    const char* sep="@.";//字符集合
    char but[30]={0};
    strcpy(but,arr);//因为会改变原数据的内容所以我们应该拷贝一份到but
   printf("%s\n" ,strtok(but,sep));//非空指针只找第一个标记，找到字符标记并把它用/0结尾，并返回w字符地址
    printf("%s\n",strtok(NULL,sep));//是从保存好的位置继续查找并返回y的地址
     printf("%s",strtok(NULL,sep));//从保存好的位置继续查找找到NULL后结束
    return 0;
}

具体代码操作如下

#include<stdio.h>
#include<string.h>
    
    
int main()
{
    char arr[]="wangxiaoming@yeah.net";
    const char* sep="@.";//字符集合
    char but[30]={0};
    strcpy(but,arr);
    char* str=NULL;
    for(str=strtok(but,sep);str!=NULL;str=strtok(NULL,sep))
    {
        printf("%s\n",str);
    }
    return 0;
}

运行结果

<二>strerror函数

char* strerror(int errnum);

◼返回错误码，所对应的错误信息。

#include<stdio.h>
#include<string.h>
#include<limits.h>
#include<errno.h>
int main()
{
    //如1，2，3数字所对应的错误信息
   	  printf("%s\n",strerror(0));
      printf("%s\n",strerror(1));
      printf("%s\n",strerror(2));
      printf("%s\n",strerror(3));
    //当然不止局限于数字如
    int* p=(int*)malloc(INT_MAX);//向堆区申请内存
    if(p==NULL)
    {
        printf("%s\n",strerror(errno));
        
        return 1;
    }
    return 0;
}

<三>字符转换函数 1.toupper 2.tolower

#include<stdio.h>
#include<stlib.h>
int main()
{
    char ch='A';
    putchar(toupper(ch));
    putchar(tololower(ch));
}

运行结果

<四>内存操作函数 1.memcpy 2.memmove 3.memcmp 4memesct

1.memcpy

int main()
{
    int arr1[10]={1,2,3,4,5,6,7,8,9,10};//目标数据
    int arr2[5]={0};//源头数据
    emecpy(arr1,arr2,20)//把源头数据以字节的方式拷贝到目标空间去
}

如下图

模拟实现memcpy

#include<stdio.h>
#include<assert.h>
void* My_memcpy(void* dest, const void* src, size_t count)
{
    assert(dest&&src);
    char* ret=dest;//把目标首元素地址先考备一份
    while(count--)//字节数减一直到为0
    {
        (char*)dest=(cahr*)src;//把src的数据以字节为单位拷贝到dest
        dest=(char*)dest+1;//dest的数据字节数加一赋值给无类型的dest
        src=(char*)src+1;//src的数据加一以字节赋值给无类型的src
    }
    return ret;//返回
}
int main()
{
    int arr1[10]={1,2,3,4,5,6,7,8,9,10};//目标数据
    int arr2[5]={0};//源头数据
    My_memcpy(arr1,arr2,20)//把源头数据以字节的方式拷贝到目标空间去
        int sz=sizeof(arr)/sizeof(arr[0]);
       for(int i=0;i<sz;i++)
       {
           printf("%d\t",arr[i]);//打印
       }
}

2.memmove

  
int main()
{
   int arr1[10]={1,2,3,4,5,6,7,8,9,10};//目标数据
    int arr2[5]={0};//源头数据
    memcpy(arr1+2,arr1,20)//如果用emecpy拷贝相同空间的数据会发生覆盖1
 //我们得到的数为 1，2，1，2，1，8，9，10
	memmove(arr1+2,arr1,20)//可以拷贝相同空间中的数据不会发生覆盖如图2
 //实际我们想要的数为 1，2，3，4，5，8，9，10
     int sz=sizeof(arr1)/sizeof(arr1[0]);
       for(int i=0;i<sz;i++)
       {
           printf("%d\t",arr1[i]);//打印
       }

}

2.memmove函数的模拟实验

void* My_memmove(void* dest,const void* src,size_t count)
{
    assert(dest&&src);//断言
     void* tmp=dest;//临时拷贝一份dest的首地址
    while(count-)
  {
         if(dest<src)
    {
        //从前向后拷贝
       *(char*)dest=*(char*)src;
        dest=(char*)dest+1;
        src=(char*)src+1;
    }
    else
    {
        //从后往前拷贝
       *((char*)dest+count)=*((char*)src+count);

    }
        
   }
    return tmp;
   
}
int main()
{
    int arr1[10]={1,2,3,4,5,6,7,8,9,10};
    My_memmove(arr1+2,arr1,20);
    int sz=sizeof(arr1)/sizeof(arr1[0]);
       for(int i=0;i<sz;i++)
       {
           printf("%d\t",arr1[i]);//打印
       }

}

3.函数memcmp

int memcmp(const void* prt1,const void* prt2,size_t num );//

int  main()
{
    int arr1[]={1,2,3,4,5,6};
    int arr1[]={1,2,3,4,5,6,7};
    memcmp(arr1,arr2,20);//比的是内存字节大小
}

4.函数memset

int main()
{
    int arr[]={1,2,3,4,5};
    memset(arr,0,20);//memset是以字节为单元初始化的
}

​ 初始化前arr的内存

初始化后arr的内存

``