1、void *mymemcpy(void *dest, const void* src, size_t n)；

内存拷贝函数，memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中

void* memcpy(void* dest,void* src,size_t n){
/ a' v0 E9 [3 d7 D. ~8 |* Q& Y- ~    assert(dest != NULL && src != NULL);

! P( L" X( U5 J* U* ~9 W, Q    if(src < dest && (char*)src + n > dest){
        char* pdst = (char*)dest+n-1;
        char* psrc = (char*)src+n-1;
        while(n--){
            *pdst-- = *psrc--;
& @+ P' X# C% t) C" H" j        }
    }else{
        char* pdest = (char*)dest;
        char* psrc = (char*)src;
% `) D  c, v0 e3 F        while(n--){
, L7 F+ P5 T8 s9 ~            *pdest++ = *psrc++;
- p) X/ `" _& @/ u" m: L        }
  ?5 R" t3 E# \: s% m$ j8 t    }
& ^# V, \6 E6 `! e    return dest;
}
( C+ o! @! ?0 x/ F4 `+ r2、void *memset(void *s, int c, size_t n);

void* memset(void* src,int c,size_t n){
    assert(src != NULL);
    char* psrc = (char*)src;
    while(n--){
        *psrc++ = (char)c;
    }
0 ~- C7 l4 S8 R) V    return src;
}
& K$ _( W- v$ H3 }8 n% d8 h3、char* strcpy(char* dest,const char* src);

char* strcpy(char* dest,const char* src){
8 c/ w+ [' g" d7 F/ x    assert(dest != NULL && src != NULL);
/ R4 D8 c/ p* z: V- o# B9 Y
1 _1 A& x* j9 J7 x1 O! ~% B! q    size_t n = strlen(src);
# y7 j9 \8 v$ q3 Z7 J& I9 ]( Y" U    if(src < dest && src + n > dest){
7 {$ e4 T6 k8 s3 I        char* pdst = dest + n;
$ K, a. W/ i: E; c' Z        *pdst-- = '\0';
        src = src + n - 1;
9 ^5 o4 w7 `4 F0 C* y0 |: m6 u        while(n--){
            *pdst-- = *src--;
- r0 x9 h- g9 R" ?+ {& N! b2 M        }
    }else{
        char* pdst = dest;
        while((*pdst++ = *src++) != 0);
! Y* J+ i7 V) e4 f4 x3 r4 f6 t    }
    return dest;
4 r( Y- x6 Y) R- c# D' J}

, H! m) H9 d8 L- i! M9 t

4、char* mystrncpy(char* dest,char* src,size_t n);

2 n- G- Y  R9 w7 \1 D

char* strncpy(char* dest,const char* src,size_t n){
+ ]  w# m8 h& }* U, r6 i    assert(dest != NULL && src != NULL);
4 L. z7 w5 L0 i) L
5 p" C+ }' _+ Q. M+ }: m& |    if(src < dest && src + n > dest){
        int m = strlen(src) < n ? strlen(src):n;
7 D1 C; ?" _3 \) H- ~        char* pdst = dest+m;
5 O3 S2 y+ V( O* A, b* V        *pdst-- = '\0';
" q8 K6 ~# [5 }: v. M        src = src + m-1;
* v- g1 n! p, X0 v; H( }; C" {        while(m--){
            *pdst-- = *src--;
8 q  m+ x7 i" F+ ?- G7 j. ?        }
& c' m) [  C7 D, i" l    }else{
        char* pdst = dest;
2 H, ]7 L7 T  f& c4 v9 T        size_t i = 0;
# V: N* T4 S$ r) u- y        while(i++ < n && (*pdst++ = *src++) != '\0');
- h& C  ^( e7 H' a        if(*(pdst-1) != '\0') *pdst = '\0';
7 d( G! g5 w; }. F. o    }
    return dest;
}
6 a0 f1 i% c8 H& S4 p$ _5、char* strcat(char* dest,const char* src)

1 f- z9 z* O9 V+ O

char* strcat(char* dest,const char* src){
    assert(dest != NULL && src != NULL);
4 u9 t+ E: m2 P5 L  F2 q    char* pdst = dest;
    while(*pdst != '\0'){
* N% a4 b" v* r; D1 `7 |* \- z        pdst++;
& ^* ]% Z- C% l3 n    }
- L; K* P3 u; J- h+ O( h    while((*pdst++ = *src++) != '\0');
2 i6 y; H2 S* _$ j/ H5 t    return dest;
+ z1 \% W. z" C6 D6 B$ x: N}
6、int strcmp(const char* s1,const char* s2)

int strcmp(const char* s1,const char* s2){
    assert(s1 != NULL && s2 != NULL);
    while(s1 && s2 && *s1 == *s2){
) P% m2 H9 J! F1 `9 \! d        s1++;
5 Q: q2 f, P) k        s2++;
    }
, M: }6 p+ H! M# R* D! B0 e1 ^    return *s1 - *s2;
% r: q) k, d6 I& B* ~2 {, D}
2 G! d; M. K* c5 `! g% q  v7、size_t strlen(const char* s)

size_t strlen(const char* src){
    assert(src != NULL);
    size_t ret = 0;
    while(*src++ != '\0'){
+ g! v/ J! u; `- {; i        ret++;
& `- \3 }5 z; X  z1 F    }
    return ret;
; `( G" M+ H0 A6 f: t}
# S" q" k5 J1 ]8 t; t0 w

用库省心一些