c++ 编程常用库函数实现

#include<stdio.h>
#include<iostream>
#include<assert.h>
#include<stdarg.h>
#include<string.h>

using namespace std;

static int is_space( int ch )
{
    return (unsigned long)(ch - 9) < 5u || ' ' == ch;
}

static int is_digit(int c)
{
    return ((c) >= '0' && (c) <= '9');
}

//复制类方法
//void *memcpy(void *dest, const void *src, size_t n);
static void *mymemcpy(void *dst,const void *src,size_t num)  
{  
    assert((dst!=NULL)&&(src!=NULL));  
    int wordnum = num/4; //计算有多少个32位，按4字节拷贝  
    int slice = num%4; //剩余的按字节拷贝  
    int * pintsrc = (int *)src;  
    int * pintdst = (int *)dst;  
    while(wordnum--)*pintdst++ = *pintsrc++;  
    while (slice--)*((char *)pintdst++) =*((char *)pintsrc++);  
    return dst;  
}  

//void *memmove(void *dest, const void *src, size_t n);
static void*  mymemmove(void *dest, const void *src,size_t n)
{
    if (n == 0)
        return 0;
 
    /* 验证参数 */
    if (dest == NULL)  return 0;
    if (src == NULL)    return 0;
 
    char *psrc = (char*)src;
    char *pdest = (char*)dest;
 
      /*检查是否有重叠问题 */
    if((dest <= psrc) || (pdest >= psrc + n))
    {
        /*正向拷贝*/
        for(int i=0; i < n; i++)
        {
                *pdest = *psrc;
                psrc++;
                pdest++;
        }
    }
    else
    {
        /*反向拷贝*/
        psrc += n;
        pdest += n;
        for(int i=0;i<n;i++)
        {
            psrc--;
            pdest--;
            *pdest = *psrc;
        }
    }
    return dest;
}

// char *strcpy(char *dest, const char *src);
static char *mystrcpy(char *dst,const char *src)  
{  
    assert(dst != NULL);  
    assert(src != NULL);  
    char *ret = dst;  
    while((* dst++ = * src++) != '\0')   
        ;  
    return ret;  
}

 //char *strncpy(char *dest, const char *src, size_t n);
 static char* mystrncpy(char *dest, const char *src, size_t n)
 {
    size_t i;
    for (i = 0 ; i < n && src[i] != '\0' ; i++)
    dest[i] = src[i];
   for ( ; i < n ; i++)
       dest[i] = '\0';
  // dest[i] = '\0';
   return dest;
 }

// int sprintf(char *str, const char *format, ...);
static int mysprintf(char *buf, const char *fmt, ...)
{
    va_list args;
    int n;

    va_start(args, fmt);
    n = vsprintf(buf, fmt, args);
    va_end(args);

    return n;
}

//void * memset ( void * ptr, int value, size_t num );
static void *mymemset(void *src, int c, size_t count)
{
     assert(src!=NULL);
     char *tmpsrc=(char*)src;
     while(count--)
      *tmpsrc++ =(char)c;
     return src;
}

static int myatoi(char *str)
{
    int sign;
    int n;
    char *p = str;

    while (is_space(*p) )
        p++;
    sign = ('-' == *p) ? -1 : 1;
    if ('+' == (*p) || '-' == (*p))
        p++;
    n=0;
    while(is_digit(*p))
    {
        n = 10 * n + ((*p) - '0');
        p++;
    }
    return sign*n;
}

//比较类方法
// int strcmp(const char *s1, const char *s2);
static int mystrcmp(const char *source,const char *dest)
{
    int ret = 0;
    if(!source || !dest) return -2;
    
    while( ! (ret = *( unsigned char *)source - *(unsigned char *)dest) && *dest)
    {
        source++;
        dest++;
    }
    
    if ( ret < 0 )
        ret = -1 ;
    else if ( ret > 0 )
        ret = 1 ;

    return(ret);
}

//int strncmp(const char *s1, const char *s2, size_t n);
static int mystrncmp(const char *first,const char *last,int count)
{
   if (!count)  return 0;
   while (--count && *first && *first == *last) first++,last++;
   return ( *(unsigned char *)first - *(unsigned char *)last );
}

//int memcmp(const void *s1, const void *s2, size_t n);
static int mymemcmp(const void *buf1,const void *buf2,int count)
{
    char* buffer1= (char *)buf1;
    char* buffer2= (char *)buf2;
    if (!count)
        return(0);
    while ( --count && *(char *)buffer1 == *(char *)buffer2)
    {
        buffer1++;
        buffer2++;
    }
    return( *((unsigned char *)buffer1) - *((unsigned char *)buffer2) );
}

//查找类方法
// char *strchr(const char *s, int c);
static char * mystrchr(const char *str, int ch)
{
    while (*str && *str != (char)ch) str++;
    if (*str == (char)ch)
        return((char *)str);
    return 0;
}

 

const char* mystrstr(const char *str,const char* tmp)
{
        for(int i = 0; str[i] != '\0';i++)
        {
                int j = 0;
                int temp=i;
                if(str[i] == tmp[j])
                {
                        while(str[i++] == tmp[j++])
                        {
                                if(tmp[j] == '\0')
                                {
                                        return &str[i-j];
                                }
                        }
                        i = temp;
                }
        }
        return NULL;
}

//计算长度类方法
// size_t strlen(const char *s);
static int mystrlen(const char * str)
{
    const char *p = str;
    while(*p++);
    return (int)(p - str - 1);
}

// size_t strnlen(const char *s, size_t maxlen);
static unsigned long mystrnlen(const char *s, int count)
{
    const char *sc;
    for (sc = s; *sc != '\0' && count--; ++sc);
    return sc - s;
}

//拼接类方法
//char *strcat(char *dest, const char *src);
static char *mystrcat(char *str1, char *str2)  
{  
    if((str1==NULL)||(str2==NULL)) throw "Invalide arguments!";  
    char *pt = str1;  
    while(*str1!='\0') str1++;  
    while(*str2!='\0') *str1++ = *str2++;  
    *str1 = '\0';  
    return pt;  
}

int main()
{
    char buf[20]={0x00};
    mymemcpy(buf,"hello world",12);
    int dd = mymemcmp(buf,"hello world",4);
    printf("dd=[%d]\n",dd);
    return 0;
}