自我实现字符串函数

字符串函数：
比较：strcmp; strncmp
拷贝：strcpy; strncpy
长度：strlen;
连接：strcat;
比较
       #include <string.h>
       int strcmp(const char *s1, const char *s2);
       int strncmp(const char *s1, const char *s2, size_t n);
功能：strcmp（） 函数比较两个字符串
s1和
s2。 它返回一个整数小于、 等于还是大于零中频s1是发现，分别要小于，要与匹配，或者是大于
s2。
strncmp()功能类似，只是它仅比较第一个 （最多）
n个字符的
s1和
s2。
返回值：Strcmp（） 和
strncmp()函数返回一个整型数小于等于或大于零如果
s1（或第
n其字节） 被发现，分别是小于对与匹配，或者是大于s2。
自己实现strcmp
  1 #include <stdio.h>
  2
  3 #define MAX_SIZE 1024
  4
  5 int my_strcmp(char*dest, char*src)
  6 {   
  7     while(*dest !='\0' && *src != '\0')
  8     {
  9         if(*dest > *src)
 10         {
 11             return 1;
 12         }
 13         if(*dest < *src)
 14         {
 15             return -1;
 16         }
 17         dest++;
 18         src++;
 19     }
 20     if(*dest == '\0' && *src == '\0')
 21     {
 22         return 0;
 23     }
 24     if(*dest != '\0' && *src == '\0')
 25     {
 26         return 1;
 27     }
 28     if(*dest == '\0' && *src != '\0')
 29     {
 30         return -1;
 31     }
 32
 33 }
 34
 35 int main ()
 36 {
 37     char src[MAX_SIZE];
 38     char dest[MAX_SIZE];
 39     int result;
 40
 41     printf("please input the src:\n");
 42     scanf("%[^\n]",src);
 43     getchar();
 44     printf("please input the dest:\n");
 45     scanf("%[^\n]",dest);
 46     
 47     result = my_strcmp(dest,src);
 48     printf("the result is %d\n",result);
 49     
 50     return 0;
 51 }
自己实现strncmp
  1 #include <stdio.h>
  2
  3 #define MAX_SIZE 1024
  4
  5 int my_strncmp(char*dest, char*src, int num)
  6 {
  7     int i;
  8     for(i = 0; i < num; i++)
  9     {
 10         if(*dest > *src)
 11         {
 12             return 1;
 13         }
 14         if(*dest < *src)
 15         {
 16             return -1;
 17         }
 18         dest++;
 19         src++;
 20     }
 21     if(*dest == *src)
 22     {
 23         return 0;
 24     }
 25
 26 }
 27
 28 int main ()
 29 {
 30     char src[MAX_SIZE];
 31     char dest[MAX_SIZE];
 32     int result;
 33     int num;
 34
 35     printf("please input the src:\n");
 36     scanf("%[^\n]",src);
 37     getchar();
 38     printf("please input the dest:\n");
 39     scanf("%[^\n]",dest);
 40     printf("please input the num:\n");
 41     scanf("%d",&num);
 42     
 43     result = my_strncmp(dest,src,num);
 44     printf("the result is %d\n",result);
 45
 46     return 0;
 47 }
 
拷贝：
       #include <string.h>
       char *strcpy(char *dest, const char *src);
       char *strncpy(char *dest, const char *src, size_t n);
描述：Strcpy（） 把函数将复制的
src指向的字符串（包括终止的
'\0'字符） 到阵列指出对
dest。 字符串不可能重叠和目标，字符串dest
必须足够大，以接收副本。
Strncpy()函数是相似的除了那不超过
n，src字节被复制。因此，如果没有空字节之间src的前
n个字节，则结果将不为空。当的
src长度小于
n，dest的其余部分将用空字节填充。
返回值：Strcpy（） 把和
strncpy()的函数返回一个指针，指向目标字符串
dest。
strcpy
  1 #include <stdio.h>
  2
  3 #define MAX_SIZE 1024
  4
  5 char* my_strcpy(char*dest, char*src)
  6 {
  7     char *temp = dest;//不能把形参作为工作变量
  8     while( *src != '\0')
  9     {
 10         *temp = *src;
 11         temp++;
 12         src++;
 13     }
 14     *temp = '\0';
 15     return dest;
 16 }
 17
 18 int main ()
 19 {
 20     char src[MAX_SIZE];
 21     char dest[MAX_SIZE];
 22     char*result;
 23
 24     printf("please input the src:\n");
 25     scanf("%[^\n]",src);
 26
 27     result = my_strcpy(dest,src);
 28     printf("the dest is %s\n",dest);
 29     printf("the result is %s\n",result);
 30
 31     return 0;
 32 }
strncpy
  1 #include <stdio.h>
  2
  3 #define MAX_SIZE 1024
  4
  5 char* my_strncpy(char*dest, char*src, int num)
  6 {
  7     char *temp = dest;//不能把形参作为工作变量
  8     int i;
  9     for(i = 0; i < num; i++)
 10     {
 11         *temp = *src;
 12         temp++;
 13         src++;
 14     }
 15     *temp = '\0';
 16     return dest;
 17 }
 18
 19 int main ()
 20 {
 21     char src[MAX_SIZE];
 22     char dest[MAX_SIZE];
 23     char*result;
 24     int num;
 25
 26     printf("please input the src:\n");
 27     scanf("%[^\n]",src);
 28     printf("please input the num:\n");
 29     scanf("%d",&num);
 30
 31     result = my_strncpy(dest,src,num);
 32     printf("the dest is %s\n",dest);
 33     printf("the result is %s\n",result);
 34
 35     return 0;
 36 }
 
长度
       #include <string.h>
       size_t strlen(const char *s);
描述：Strlen（） 函数计算长度的字符串，不包括终止的
'\0'字符。
返回值：Strlen（） 函数在
s中返回字符的数
strlen
  1 #include <stdio.h>
  2
  3 #define MAX_SIZE 1024
  4
  5 int my_strlen(char*src)
  6 {
  7     int count = 0;
  8     while( *src != '\0')
  9     {
 10         count++;
 11         src++;
 12     }
 13     return count;
 14 }
 15
 16 int main ()
 17 {
 18     char src[MAX_SIZE];
 19     int len;
 20
 21     printf("please input the src:\n");
 22     scanf("%[^\n]",src);
 23
 24     len = my_strlen(src);
 25     printf("the len is %d\n",len);
 26
 27     return 0;
 28 }
 
连接：
       #include <string.h>
    char *strcat(char *dest, const char *src);
       char *strncat(char *dest, const char *src, size_t n);
描述：Strcat()函数将
src字符串追加到
dest字符串覆盖在
dest，末尾的'\0'
字符，然后添加终止的'\0'
字符。 字符串不可能过一圈和dest
字符串必须有足够的空间，结果。
Strncat()功能类似，只是它将使用从
src最
n 个字符。 因为结果总是名词术语试验与
'\0'，都写在最n + 1
个字符。
返回值：Strcat()和
strncat()函数返回一个指向生成的字符串个数相加。
strcat
  1 #include <stdio.h>
  2
  3 #define MAX_SIZE 1024
  4
  5 char* my_strcat(char*dest, char*src)
  6 {
  7     char *temp = dest;//不能把形参作为工作变量
  8     while( *temp != '\0')
  9     {
 10         temp++;
 11     }
 12     while( *src != '\0')
 13     {
 14         *temp = *src;
 15         temp++;
 16         src++;
 17     }
 18     *temp = '\0';
 19     return dest;
 20 }
 21
 22 int main ()
 23 {
 24     char src[MAX_SIZE];
 25     char dest[MAX_SIZE];
 26     char*result;
 27
 28     printf("please input the src:\n");
 29     scanf("%[^\n]",src);
 30     getchar();
 31     printf("please input the dest:\n");
 32     scanf("%[^\n]",dest);
 33
 34     result = my_strcat(dest,src);
 35     printf("the dest is %s\n",dest);
 36     printf("the result is %s\n",result);
 37
 38     return 0;
 39 }

memset
简介
<string.h> #include
void *
块 (void * s，int c，size_t n);
描述
memset()
函数填充与恒定字节 c s 所指向的内存区域的第
n 个字节。
返回值
memset()
函数返回一个指向内存区 s。
 
bzero
简介
<strings.h> #include
void bzero (void * s，size_t n);
描述
bzero()
函数设置字节地区起价 s 为零 （字节包含
'\0'） 前的
n 个字节。
返回值
空
 
 
 
SYNOPSIS
       #include <stdlib.h>
 
       void *calloc(size_t nmemb, size_t size);
       void *malloc(size_t size);
       void free(void *ptr);
       void *realloc(void *ptr, size_t size);
 
描述
calloc()
为 nmemb 大小的字节数每个元素的数组分配内存，并返回一个指向所分配的内存。内存设置为零。

malloc
（） 分配大小字节，并返回一个指向所分配的内存。不清除内存。
free()
释放 ptr，必须经由先前调用
malloc （）、
calloc() 或
realloc() 所指向的内存空间。 否则为或者如果
free(ptr) 已被调用之前，发生在未定义的行为。 如果
ptr 是
NULL，则执行没有概略。
realloc()
更改大小字节的 ptr
所指向的内存块的大小。 内容将保持不变的旧的和新的大小;
和最小和对新分配的内存将被初始化。 如果 ptr
是 NULL，电话就等于
mal-loc(size);如果大小等于零，电话就等于
free(ptr)。 除非
ptr 为
NULL，则它必须被返回由先前调用
malloc （）、
calloc() 或
realloc()。 如果指向的区域被移动，free(ptr)
是完成的。
返回值
对于
calloc() 和 malloc
（），返回的值是一个指向所分配的内存，适当地对齐的任何类型的变量，则返回 NULL，如果请求失败。
free()
不返回值。
realloc()
返回一个指向新分配的内存，是适当地对齐的任何类型的变量和可能不同从 ptr，或如果请求失败，则为
NULL。 如果尺寸等于
0，则返回
NULL 或适合要传递给
free() 的指针。 如果
realloc() 失败原来的块是保持不变;它不是释放或移动。
 
区别:
    (1)函数malloc不能初始化所分配的内存空间,而函数calloc能.如果由malloc()函数分配的内存空间原来没有被使用过，则其中的每一位可能都是0;反之,
如果这部分内存曾经被分配过,则其中可能遗留有各种各样的数据.也就是说，使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常进行,但经过一段时间(内存空间还已经被重新分配)可能会出现问题.
    (2)函数calloc()
会将所分配的内存空间中的每一位都初始化为零,也就是说,如果你是为字符类型或整数类型的元素分配内存,那么这些元素将保证会被初始化为0;如果你是为指针类型的元素分配内存,那么这些元素通常会被初始化为空指针;如果你为实型数据分配内存,则这些元素会被初始化为浮点型的零.
    (3)函数malloc向系统申请分配指定size个字节的内存空间.返回类型是
void*类型.void*表示未确定类型的指针.C,C++规定，void*
类型可以强制转换为任何其它类型的指针.
    (4)realloc可以对给定的指针所指的空间进行扩大或者缩小，无论是扩张或是缩小，原有内存的中内容将保持不变.当然，对于缩小，则被缩小的那一部分的内容会丢失.realloc并不保证调整后的内存空间和原来的内存空间保持同一内存地址.相反，realloc返回的指针很可能指向一个新的地址.
(5)realloc是从堆上分配内存的.当扩大一块内存空间时，realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，如果能够满足，自然天下太平；如果数据后面的字节不够，问题就出来了，那么就使用堆上第一个有足够大小的自由块，现存的数据然后就被拷贝至新的位置，而老块则放回到堆上.这句话传递的一个重要的信息就是数据可能被移动.

 
指针+/-整数（指针的步长）
指针-指针=两个指针之间地址相隔的数据个数