字符串函数的原型实现(strcpy, strcat, strcmp, memset, memcpy, memmove)

#include <iostream>
#include <cassert>
using namespace std;
typedef int size_t;
//原型函数
char *strcpy(char *dest, const char *src);
char *strncpy(char *dest,char *src,size_t n);
char *strcat(char *dest,char *src);
int strcmp(const char *s1,const char * s2);
void *memset(void *s, int ch, size_t n);
void *memcpy(void *dest, const void *src, size_t n);
void *memmove( void *dest, const void *src, size_t n);

int main(){
    return 0;
}

//1、char *strcpy(char *dest, const char *src);
/**
dest 目的地址
src 原地址
从src开始地址且含有NULL结束符的字符串复制到dest开始的地址
**/
char *strCpy(char *dest,const char *src){
    assert(NULL!=dest&&NULL!=src);
    char *destCpy=dest;
    while((*destCpy++=*src++)!='\0'){};
    return dest;
}

//2.char *strncpy(char *dest,char *src,size_t n);
/**
dest 目的地址
src 原地址
size_t n表示字节数如char buffer[4];就要表示n=sizeof(char)*4

将src开始地址的n个字符串内容复制到dest开始的地址空间，至于复制多少由n决定，
如果n>src内容长度，则以NULL填补dest直到复制完成n个字符；
如果n<src长度，则会正常复制前n个字符，dest不可与src内存地址重叠，
且dest必须有足够的内存存放dest长度+'\0'
**/
char *strnCpy(char *dest,char *src,size_t n){
    assert(NULL!=dest&&NULL!=src&&n>0);
    char *destCpy=dest;
    char *srcCpy=src;
    while(n--&&(*destCpy++=*srcCpy++)!='\0'){
    }
    if(n>0){
        while(n--){
            *destCpy++='\0';    
        }    
    }
    return dest;
}

//3、char *strcpy(char *dest, const char *src);
/**
dest 目的地址
src 原地址

将src指向的字符串添加到dest的结尾处并添加'\0'
**/
char *strcat(char *dest,char *src){
    assert(NULL!=dest&&NULL!=src);
    char *destCpy=dest;
    while(*destCpy!='\0'){
        destCpy++;
    }
    while((*destCpy++=*src++)!='\0'){
    }
    return dest;
}

//4.int strcmp(const char *s1,const char * s2);
/**
s1 比较字符串
s2 比较字符串

两个字符串比较，如s1==s2,返回0，s1>s2,返回1，s1<s2，返回-1
**/
int strcmp(const char *s1,const char *s2){
    assert(NULL!=s1&&NULL!=s2);
    while(*s1==*s2){
        if(*s1=='\0'){
            return 0;
        }
        s1++;
        s2++;
    }
    if(*s1>*s2){
        return 1;
    }else{
        return -1;
    }
}

//5.void *memset(void *s, int ch, size_t n);
/**
s 待处理字符串
ch 代替字节
n 字节数
//将s中前n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s
//一般用于数据结构的清零处理
**/
void *memset(void *s,int ch,size_t n){
    assert(NULL!=s&&n>0);
    char *sCpy=(char *)s;//注意这里void要转换s
    while(n--){
        *sCpy++=ch;
    }
    return s;
}

//6.void *memcpy(void *dest, const void *src, size_t n)
/**
dest 目的结构地址
src 原始结构地址
n 字节数

将src开始地址的n个字节内容复制到dest开始的地址空间，
如果n>src内容长度，则以NULL填补dest直到复制完成n个字符；
如果n<src长度，则会正常复制前n个字符，dest不可与src内存地址重叠，//且dest必须有足够的内存存放dest长度+’\0’

//与strncpy区别：
主要是复制的内容区别，strncpy只能复制字符串，
而memcpy可以复制任何内容，如字符数组，整型，结构体，类等。

//与strcpy区别：
1、复制的内容不同
2、复制的方法不同,strcpy不需要指定长度，它遇到被复制字符的串结束
符’\0’才结束，所以容易使缓冲区溢出
3、用途不同，通常在复制字符串时用strcpy，而需要复制其他类型数据时则
一般用memcpy
**/

void *memcpy(void *dest,const void *src,size_t n){
    assert(NULL!=dest&&NULL!=src&&n>0);
    char *destCpy=(char *)dest;//注意这里void要转换
    const char *srcCpy=(const char *)src;//注意这里void要转换
    while(n--){
        *destCpy++=*srcCpy++
    }
    return dest;
}

//7.void *memmove( void *dest, const void *src, size_t n)
/**
dest 目的结构地址
src 原始结构地址
n 字节数

将src开始地址的n个字节内容复制到dest开始的地址空间，
如果n>src内容长度，则以NULL填补dest直到复制完成n个字符；
如果n<src长度，则会正常复制前n个字符，dest可与src内存地址重叠，
且dest必须有足够的内存存放dest长度+’\0’
如果目标区域dest和源区域src有重叠的话，memmove能够保证源串src在
被覆盖之前将重叠区域的字节拷贝到dest目标区域中。但复制后src内容会被更改
**/
void *memmove(void *dest,const void *src,size_t n){
    assert(NULL!=dest&&NULL!=src&&n>0);
    char *destCpy=(char *)dest;//注意这里void要转换
    const char *srcCpy=(const char *)src;//注意这里void要转换
    if((destCpy>=srcCpy+n)||srcCpy>=destCpy){
        for(int i=0;i<n;i++){
            *destCpy++=*srcCpy++;
        }
    }else{//src<dest<src+n从末尾处开始赋值
        destCpy+=n;
        srcCpy+=n;
        for(int i=0;i<n;i++){
            *destCpy--=*srcCpy--;
        }
    }
    return dest;
}