自我实现字符串函数

字符串函数：

比较：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()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，如果能够满足，自然天下太平；如果数据后面的字节不够，问题就出来了，那么就使用堆上第一个有足够大小的自由块，现存的数据然后就被拷贝至新的位置，而老块则放回到堆上.这句话传递的一个重要的信息就是数据可能被移动.

 

指针+/-整数（指针的步长）

指针-指针=两个指针之间地址相隔的数据个数