C++博客-Life is Good.-随笔分类-C字符串函数源码分析

15 - memchr

Mike Song — Sat, 11 Jun 2011 14:11:00 GMT

/***
*char *memchr(buf, chr, cnt) - search memory for given character.
*
*Purpose:
*       Searches at buf for the given character, stopping when chr is
*       first found or cnt bytes have been searched through.
*
*Entry:
*       void *buf  - memory buffer to be searched
*       int chr    - character to search for
*       size_t cnt - max number of bytes to search
*
*Exit:
*       returns pointer to first occurence of chr in buf
*       returns NULL if chr not found in the first cnt bytes
*
*Exceptions:
*
*******************************************************************************/

void * __cdecl memchr (
        const void * buf,
        int chr,
        size_t cnt
        )
{
        while ( cnt && (*(unsigned char *)buf != (unsigned char)chr) ) {
                buf = (unsigned char *)buf + 1;
                cnt--;
        }

        return(cnt ? (void *)buf : NULL);
}

Mike Song 2011-06-11 22:11 发表评论

14 - memcpy and memmove difference

Mike Song — Sat, 11 Jun 2011 14:09:00 GMT

/***
*memmove - Copy source buffer to destination buffer
*
*Purpose:
*       memmove() copies a source memory buffer to a destination memory buffer.
*       This routine recognize overlapping buffers to avoid propogation.
*       For cases where propogation is not a problem, memcpy() can be used.
*
*Entry:
*       void *dst = pointer to destination buffer
*       const void *src = pointer to source buffer
*       size_t count = number of bytes to copy
*
*Exit:
*       Returns a pointer to the destination buffer
*
*Exceptions:
*******************************************************************************/

void * __cdecl mymemcpy (
  void * dst,
  const void * src,
  size_t count
  )
{
  void * ret = dst;
  /*
  * copy from lower addresses to higher addresses
  */
  while (count--) {
    *(char *)dst = *(char *)src;
    dst = (char *)dst + 1;
    src = (char *)src + 1;
  }

  return(ret);
}

void * __cdecl mymemmove (
  void * dst,
  const void * src,
  size_t count
  )
{
  void * ret = dst;

  if (dst <= src || (char *)dst >= ((char *)src + count)) {
    /*
    * Non-Overlapping Buffers
    * copy from lower addresses to higher addresses
    */
    while (count--) {
      *(char *)dst = *(char *)src;
      dst = (char *)dst + 1;
      src = (char *)src + 1;
    }
  }
  else {
    /*
    * Overlapping Buffers
    * copy from higher addresses to lower addresses
    */
    dst = (char *)dst + count - 1;
    src = (char *)src + count - 1;

    while (count--) {
      *(char *)dst = *(char *)src;
      dst = (char *)dst - 1;
      src = (char *)src - 1;
    }
  }

  return(ret);
}

int _tmain(int argc, _TCHAR* argv[])
{
  int i = 0;
  int a[10];

  for(i; i < 10; i++)
  {
    a[i] = i;
  }

  mymemcpy(&a[4], a, sizeof(int)*6);

  for(i = 0; i < 10; i++)
  {
    printf("%d ",a[i]);
  }

  printf("\n");

  for(i=0; i < 10; i++)
  {
    a[i] = i;
  }
  mymemmove(&a[4], a, sizeof(int)*6);

  for(i = 0; i < 10; i++)
  {
    printf("%d ",a[i]);
  }

  printf("\n");

    return 0;
}

Result:
0 1 2 3 0 1 2 3 0 1
0 1 2 3 0 1 2 3 4 5

Mike Song 2011-06-11 22:09 发表评论

13 - memmove

Mike Song — Sat, 11 Jun 2011 13:52:00 GMT

Mike Song 2011-06-11 21:52 发表评论

12 - memset

Mike Song — Sat, 11 Jun 2011 13:32:00 GMT

/***
*char *memset(dst, val, count) - sets "count" bytes at "dst" to "val"
*
*Purpose:
*       Sets the first "count" bytes of the memory starting
*       at "dst" to the character value "val".
*
*Entry:
*       void *dst - pointer to memory to fill with val
*       int val   - value to put in dst bytes
*       size_t count - number of bytes of dst to fill
*
*Exit:
*       returns dst, with filled bytes
*
*Exceptions:
*
*******************************************************************************/

void * __cdecl memset (
  void *dst,
  int val,
  size_t count
  )
{
  void *start = dst;

  while (count--) {
    *(char *)dst = (char)val;
    dst = (char *)dst + 1;

  return(start);
}

Mike Song 2011-06-11 21:32 发表评论

11 - memcpy

Mike Song — Sat, 11 Jun 2011 13:30:00 GMT

/***
*memcpy - Copy source buffer to destination buffer
*
*Purpose:
*       memcpy() copies a source memory buffer to a destination memory buffer.
*       This routine does NOT recognize overlapping buffers, and thus can lead
*       to propogation.
*
*       For cases where propogation must be avoided, memmove() must be used.
*
*Entry:
*       void *dst = pointer to destination buffer
*       const void *src = pointer to source buffer
*       size_t count = number of bytes to copy
*
*Exit:
*       Returns a pointer to the destination buffer
*
*Exceptions:
*******************************************************************************/

void * __cdecl memcpy (
  void * dst,
  const void * src,
  size_t count
  )
{
  void * ret = dst;
  /*
  * copy from lower addresses to higher addresses
  */
  while (count--) {
    *(char *)dst = *(char *)src;
    dst = (char *)dst + 1;
    src = (char *)src + 1;
  }

  return(ret);
}

Mike Song 2011-06-11 21:30 发表评论

10 - strupr

Mike Song — Sat, 11 Jun 2011 13:18:00 GMT

char * __cdecl _strupr (  char * string  )
{
  char *cp;       /* traverses string for C locale conversion */
  for (cp = string; *cp; ++cp)
  {
    if ('a' <= *cp && *cp <= 'z')
      *cp += 'A' - 'a';
  }
  return(string);
} /* C locale */

Mike Song 2011-06-11 21:18 发表评论

9 - strchr

Mike Song — Sat, 11 Jun 2011 13:11:00 GMT

/***
*char *strchr(string, c) - search a string for a character
*
*Purpose:
*       Searches a string for a given character, which may be the
*       null character '\0'.
*
*Entry:
*       char *string - string to search in
*       char c - character to search for
*
*Exit:
*       returns pointer to the first occurence of c in string
*       returns NULL if c does not occur in string
*
*Exceptions:
*
*******************************************************************************/

char * __cdecl strchr (
        const char * string,
        int ch
        )
{
        while (*string && *string != (char)ch)
                string++;

        if (*string == (char)ch)
                return((char *)string);
        return(NULL);
}

Mike Song 2011-06-11 21:11 发表评论

8 - strset

Mike Song — Sat, 11 Jun 2011 13:09:00 GMT

/***
*char *_strset(string, val) - sets all of string to val
*
*Purpose:
*       Sets all of characters in string (except the terminating '/0'
*       character) equal to val.
*
*
*Entry:
*       char *string - string to modify
*       char val - value to fill string with
*
*Exit:
*       returns string -- now filled with val's
*
*Uses:
*
*Exceptions:
*
*******************************************************************************/

char * __cdecl _strset (
  char * string,
  int val
  )
{
  char *start = string;

  while (*string)
    *string++ = (char)val;

  return(start);
}

Mike Song 2011-06-11 21:09 发表评论

7 - strdup

Mike Song — Thu, 02 Jun 2011 15:16:00 GMT

/***
*char *_strdup(string) - duplicate string into malloc'd memory
*
*Purpose:
*       Allocates enough storage via malloc() for a copy of the
*       string, copies the string into the new memory, and returns
*       a pointer to it.
*
*Entry:
*       char *string - string to copy into new memory
*
*Exit:
*       returns a pointer to the newly allocated storage with the
*       string in it.
*
*       returns NULL if enough memory could not be allocated, or
*       string was NULL.
*
*Uses:
*
*Exceptions:
*
*******************************************************************************/

char * __cdecl _strdup (
        const char * string
        )
{
        char *memory;

        if (!string)
                return(NULL);

        if (memory = malloc(strlen(string) + 1))
                return(strcpy(memory,string));

        return(NULL);
}

Mike Song 2011-06-02 23:16 发表评论

6 - strcat

Mike Song — Thu, 02 Jun 2011 14:18:00 GMT

/***
*char *strcat(dst, src) - concatenate (append) one string to another
*
*Purpose:
*       Concatenates src onto the end of dest.  Assumes enough
*       space in dest.
*
*Entry:
*       char *dst - string to which "src" is to be appended
*       const char *src - string to be appended to the end of "dst"
*
*Exit:
*       The address of "dst"
*
*Exceptions:
*
*******************************************************************************/

char * __cdecl strcat (
        char * dst,
        const char * src
        )
{
        char * cp = dst; // 得到首地址, 然后遍历到最后, 再copy

        while( *cp )
                cp++;                   /* find end of dst */

        while( *cp++ = *src++ ) ;       /* Copy src to end of dst */

        return( dst );                  /* return dst */

}

int _tmain(int argc, _TCHAR* argv[])
{
  char s1[] = "abc";
  char s2[] = "def";
  char* p = my_strcat(s1, s2);

  return 0;
}

Mike Song 2011-06-02 22:18 发表评论

5 - strstr

Mike Song — Thu, 02 Jun 2011 14:07:00 GMT

/***
*char *strstr(string1, string2) - search for string2 in string1
*
*Purpose:
*       finds the first occurrence of string2 in string1
*
*Entry:
*       char *string1 - string to search in
*       char *string2 - string to search for
*
*Exit:
*       returns a pointer to the first occurrence of string2 in
*       string1, or NULL if string2 does not occur in string1
*
*Uses:
*
*Exceptions:
*
*******************************************************************************/

char * __cdecl strstr (
        const char * str1,
        const char * str2
        )
{
        char *cp = (char *) str1;
        char *s1, *s2;

        if ( !*str2 )
            return((char *)str1);

        while (*cp)
        {
                s1 = cp;
                s2 = (char *) str2;

                while ( *s1 && *s2 && !(*s1-*s2) )
                        s1++, s2++;

                if (!*s2)
                        return(cp);

                cp++;
        }

        return(NULL);

}

int _tmain(int argc, _TCHAR* argv[])
{
  char* p1 = "abcde";
  char* p2 = "cd";

  char* p = my_strstr(p1, p2);

  return 0;
}

Mike Song 2011-06-02 22:07 发表评论

4 - strcmp

Mike Song — Thu, 02 Jun 2011 13:49:00 GMT

/***
*strcmp - compare two strings, returning less than, equal to, or greater than
*
*Purpose:
*       STRCMP compares two strings and returns an integer
*       to indicate whether the first is less than the second, the two are
*       equal, or whether the first is greater than the second.
*
*       Comparison is done byte by byte on an UNSIGNED basis, which is to
*       say that Null (0) is less than any other character (1-255).
*
*Entry:
*       const char * src - string for left-hand side of comparison
*       const char * dst - string for right-hand side of comparison
*
*Exit:
*       returns -1 if src <  dst
*       returns  0 if src == dst
*       returns +1 if src >  dst
*
*Exceptions:
*
*******************************************************************************/

int __cdecl strcmp (
        const char * src,
        const char * dst
        )
{
        int ret = 0 ;

        while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
                ++src, ++dst;

        if ( ret < 0 )
                ret = -1 ;
        else if ( ret > 0 )
                ret = 1 ;

        return( ret );
}

int _tmain(int argc, _TCHAR* argv[])
{
  char* p1 = "abcde";
  char* p2 = "abchd";

  int i = my_strcmp(p1, p2);

  return 0;
}

Mike Song 2011-06-02 21:49 发表评论

3 - strlen

Mike Song — Thu, 02 Jun 2011 13:38:00 GMT

/***
*strlen - return the length of a null-terminated string
*
*Purpose:
*       Finds the length in bytes of the given string, not including
*       the final null character.
*
*Entry:
*       const char * str - string whose length is to be computed
*
*Exit:
*       length of the string "str", exclusive of the final null byte
*
*Exceptions:
*
*******************************************************************************/

size_t __cdecl strlen ( const char * str )
{
  const char *eos = str;

  while( *eos++ ) ;

  return( (int)(eos - str - 1) );
}

int _tmain(int argc, _TCHAR* argv[])
{
  char str[] = "abcde";
  int n = strlen(str);

  return 0;
}

Mike Song 2011-06-02 21:38 发表评论

2 - strcpy

Mike Song — Thu, 02 Jun 2011 08:40:00 GMT

/***
*char *strcpy(dst, src) - copy one string over another
*
*Purpose:
*       Copies the string src into the spot specified by
*       dest; assumes enough room.
*
*Entry:
*       char * dst - string over which "src" is to be copied
*       const char * src - string to be copied over "dst"
*
*Exit:
*       The address of "dst"
*
*Exceptions:
*******************************************************************************/

char * __cdecl strcpy(char * dst, const char * src)
{
        char * cp = dst;

        while( *cp++ = *src++ )
                ;               /* Copy src over dst */

        return( dst );
}

int _tmain(int argc, _TCHAR* argv[])
{
  char* src = "abc";
  char* dest = (char*)malloc(strlen(src)+1);
  memset(dest, 0x00, sizeof(strlen(src)+1));

  dest = strcpy(dest, src);

  free(dest);
  dest = NULL;

  return 0;
}

Mike Song 2011-06-02 16:40 发表评论

1 - strrev

Mike Song — Wed, 01 Jun 2011 15:12:00 GMT

/***
*strrev.c - reverse a string in place
*
*       Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
*
*Purpose:
*       defines _strrev() - reverse a string in place (not including
*       '\0' character)
*
*******************************************************************************/

#include <cruntime.h>
#include <string.h>

/***
*char *_strrev(string) - reverse a string in place
*
*Purpose:
*       Reverses the order of characters in the string.  The terminating
*       null character remains in place.
*
*Entry:
*       char *string - string to reverse
*
*Exit:
*       returns string - now with reversed characters
*
*Exceptions:
*
*******************************************************************************/

char * __cdecl _strrev (char * string)
{
        // 此段程序的start/left/string 都在同一块内存中, start记录的是起始地址,未变动过
        // left和string 由于要交换数据, 所以会有变化
        char *start = string;
        char *left = string;
        char ch;

        while (*string++)                 /* find end of string */
                ;
        string -= 2; // 指针后退2, 得到最后一个字符的指针地址.

        // 此段逻辑就是前后字符交换, 比如 "abcde":
        // 第一次循环, a 和 e 交换后变成ebcda,
        // 第二次循环b和d交换, 变成edcba,
        // 第三次由于left==string, 故循环停止.
        while (left < string)
        {
                ch = *left;
                *left++ = *string; // 此处可分解为两步更好理解: *left =*sting; left++; 把值付给*left, 然后left向后移位
                *string-- = ch;      // 同上: *string = ch; string--; 把值付给*string, 然后string向前移位
        }

        return(start);
}

另外一种利用strlen函数来得到字符串长度的方法, 其原理跟上面的相同: 首尾依次交换到中间为止.

char* my_strrev(char* p)
{
  int n = strlen(p);
  int i = 0;
  int j = 0;
  char ch;

  for (i = 0, j = n-1; i < j; i++, j--)
  {
    ch = p[i];
    p[i] = p[j];
    p[j]=ch;
  }

  return p;
}

int _tmain(int argc, _TCHAR* argv[])
{
  // 此处不能定义为char* p = "abcde";
  // 因为在strrev里面要修改p的内容.
  char p[] = "abcde";
  char* p1 = strrev(p);
  char* p2 = my_strrev(p);

  return 0;
}

Mike Song 2011-06-01 23:12 发表评论