当前位置：首页 > news >正文

【C/C++】内存和字符操作整理

news 来源：原创 2024/4/28 16:12:04

内存清零memset

memset:

拷贝(3+2+2+1)

memcpy:

memmove:

memccpy:

strncpy:

strcpy:

strncat:

strcat:

strdup:

查找：

memchr:

strchr:

index:

strrchr:

rindex:

strstr:

strcspn:

strspn:

比较：

memcmp:

strcmp:

strncasecmp:

strcasecmp:

切割：

strtok:

在有关内存操作的函数中，其函数参数为void * ，按照ANSI标准，不能对void指针进行算法操作，即不能对void指针进行如p++的操作,所以需要转换为具体的类型指针来操作,例如char *。

注意：若是用使用strcpy、memset 、memcpy 等涉及到修改空间内容的函数或操作(如s[i] = ‘m’)时，要看看原有字符串的‘\0’ 有没有被覆盖掉，或者是cpy时没有将原字符串的尾部‘\0’赋值过来，如果这样的话，要手工给新字符串的末尾添一个‘\0’ 。

================================================================================================

内存清零memset

memset:

void *memset(void *s, int ch, size_t n);

第一个参数是内存起始地址，第二个参数是设置内存空间每个字节的值，第三个参数是设定的内存空间的长度(字节的个数，不是元素个数)。

memset()会将参数指针s所指的内存区域的前n个字节以参数c填入，然后返回指向s的指针;

int ch 是填入一个字节的，是针对一个字节的值，所以c 的取值只能做到一个字节的空间0~255

因为是void *s ,所以是对一段内存的操作，不管这个内存存储的数据类型是什么，只要指定count大小，都将会将以buffer为起始地址的count字节的存储内容值统一赋为c 。

若我们将int ch = 0; 或int ch = '\0' 都会将这段内存清零(事实上字符’\0‘的ASCII码的值就为0，而在内存中任何字符都是以ASCII码来进行存储的，127以下的整数可以和字符进行通用，所以int c = 0 或 ’\0‘都是等效的，只是后者更习惯用于对字符串的清0，而前者都通用)。

memset() 函数常用于内存空间初始化(初始化为0)，还用于一段已用内存空间的清零，常用于以下几种情况：

用于局部动态未初始化数组清0：

main()

{

    int a[10];

    memset(a, 0, sizeof(a)); //事实上，这个清零也可以在定义时初始化int a[10] = {0};来实现

}

用于结构体对象清0：

typedef struct Stu
{

    char name[24];// 24是为了充分利用空间，因为字节对齐

    int id;

    Stu *next;

} Stu;

main()
{

    Stu stu1;
    ?//这时候得到的结构体里面的成员都是局部动态变量，其初始值都为随机值，只有单stu1为全局的时候，才能为默认值，即stu1本身即为一个变量，只不过类型自定义

    memset(&stu1, 0, sizeof(Stu));

}

常见的memset的误用及滥用：

情况一、对整形数组进行清0 则memset(a,0,sizeof(a)) 与 int a[10] = {0};效果是相同的，但若是要给数组进行赋给一个相同的值如1，则memset(a,1，sizeof(a))是不能达到的，因为memset是对每个字节赋值，而每个整形数组的元素占4个字节，那么这样赋值完以后，对a指向的内存的20个字节进行赋值，每个都用ASCII为1的字符去填充，转为二进制后，1就是00000001,占一个字节。一个INT元素是4字节，合一起就是1000000010000000100000001，就等于16843009而不是1；

情况二、对于由malloc开辟的空间，其返回的空间的内容是随机的，是不确定的内容，所以最好要memset 一下，别忘了！而内核空间的kmalloc也是一样！

Stu *stu2 = (Stu *)malloc(sizeof(Stu));

memset(stu2,0,sizeof(Stu)); //——良好的习惯

情况三、错误想法：对于定义后确定会马上赋值了的，则不用memset ,

良好习惯：对于定义后未初始化的，都一律最好清零--------尤其是字符数组，一定要！！！

一些可能有某种心理阴影, 他们惧怕未经初始化的内存, 所以他们会写出这样的代码:

char buffer[20];

memset(buffer, 0, sizeof((char)*20));
strcpy(buffer, "123");

这里的memset是多余的. 因为这块内存马上就被覆盖了, 清零没有意义----------错误！！！

如：

main()
{
    int i;
    char gs[20];

    //memset(gs,0,20); //为的是将每一个字符都充满’\0‘
    printf("input a string:\n");
    gets(gs);
    printf("gs:%s\n", gs);
    for(i = 0; i < 20; i++)
        printf("%c", gs[i]); //后面的为乱码，说明gets并不会将后面的空值也赋为0，仅是前面的覆盖，所以说数组若未初始化则要马上清零是多么重要!

    strncpy(gs + 3, gs, 20); //若数组起始未清过零，则'\0'后的区域仍残留随机值，则输出的是错误结果

    printf("gs:%s\n", gs);
    printf("\n");

}

输入：123456789

输出：123456789(U, � //看看，连随机值也一起拷贝了

memset主要应用是初始化某个内存空间。
memcpy是用于copy源空间的数据到目的空间中。
strcpy用于字符串copy,遇到‘/0’，将结束。

原型：extern char *strcpy(char *dest,char *src);
用法：＃i nclude
功能：把src所指由NULL结束的字符串复制到dest所指的数组中。
说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
返回指向dest的指针。
memcpy
原型：extern void *memcpy(void *dest, void *src, unsigned int count);
用法：＃i nclude
功能：由src所指内存区域复制count个字节到dest所指内存区域。
说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。
memset
原型：extern void *memset(void *buffer, int c, int count);
用法：＃i nclude
功能：把buffer所指内存区域的前count个字节设置成字符c。
说明：返回指向buffer的指针。

memcpy用来做内存拷贝，你可以拿它拷贝任何数据类型的对象，可以指定拷贝的数据长度。

例：char a[100],b[50]; memcpy(b, a, sizeof(b));注意如用sizeof(a)，会造成b的内存地址溢出。

Strcpy 就只能拷贝字符串了，它遇到'/0'就结束拷贝。

====================================================================================================================================

拷贝(3+2+2+1)

覆盖: memmove、memccpy、memcpy --3

覆盖:strncpy、strcpy --2

覆盖: strncat、strcat --2

生成：strdup --1

...................对于strcat 和 strcpy 只要空间允许，都会将‘\0’一起复制过去！！！

——能实现空间重叠的只有memmove;

——本身自己能完成字符串赋值的是strcpy

——memcpy和strncpy相对与字符串操作来说是完全相同的，即一段空间覆盖、手工添加'\0'、注意size_t n的大小限制、不能实现空间重叠

——memmove除了允许空间重叠，其它同memcpy和strncpy，即一段空间覆盖、手工添加'\0' ( dest[ n] = '\0')、注意size_t n的大小限制

——strcpy除了实现的是一个完整字符串赋值，还要考虑源字符串与目的字符串合法空间的大小关系，还有一定要遵守的是不能实现空间重叠；

——strncat、strcat其实和strncpy、strcpy的实现是一样的，只不过是将目的字符串指针dest改为字符串的尾部'\0'起始的地址而已，其它的与strncpy、strcpy一样，strncat也要手工添0，strncat和strcat大小也要控制，不过两个都不存在空间重叠的限制，因为dest为尾指针，目的空间是空的。

memcpy、memmove、memccpy、strncpy、strcpy、strncat、strcat都是在已有的字符串空间进行覆盖，是两个实体间部分空间的值的拷贝；但strdup 不一样，它是利用malloc、strcpy来克隆出另一个完完全全相同的字符串实体，只是原有字符串实体空间与新生成字符串实体空间的首地址不同，其它的大小和值都一样，新生成的字符串实体的首地址作为返回值。

——strdup完全没有限制，因为它是完成的是克隆的功能，利用了malloc 和strcpy

名词解释：

空间重叠：即目的字符串的开头不能与源字符串的结尾重叠，而目的字符串的末尾与原字符串的开头重叠是可以的！！！

大小关系：strcpy的大小关系，即是源字符串的大小(包括'\0')要小于目的字符串合法空间的大小——防溢出！

而其它的则是size_t n 要小于等于 (dest 的合法空间大小和src的合法空间大小)的最小值——否则无论n超出哪一个的大小，都会造成溢出！

手工加'\0': 即dest [ n]= '\0' ;

溢出：即对非法空间进行的操作，造成不可预知的结果！

——原理是利用一个空间的值去覆盖另一个空间，而并不是复制。而没有被覆盖到的原字符串后面的字符仍然保留；若要实现字符串复制的话，则需要要手动添加一个'\0'；

——size_t n 一定要注意它的值，最大不能超过(dest 的合法空间大小和src的合法空间)的最小值！！！

——除memmove以外，空间不能重叠，即目的字符串的开头不能与源字符串的结尾重叠，而目的字符串的末尾与原字符串的开头重叠是可以的！！！

memcpy:

void * memcpy (void * dest ,const void *src, size_t n);返回复制后的dest指针。

memcpy(拷贝内存内容)
相关函数	bcopy，memccpy，memcpy，memmove，strcpy，strncpy
表头文件	#include<string.h>
定义函数	void * memcpy (void * dest ,const void *src, size_t n);
函数说明	memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。与strcpy()不同的是，memcpy()会完整的复制n个字节，不会因为遇到字符串结束'\0'而结束，可用于一般的内存拷贝或拷贝含'\0'的多个字符串空间。
返回值	返回指向dest的指针。
附加说明	指针src和dest所指的内存区域不可重叠。
范例	#include<string.h> main() { char a[30]="string (a)"; char b[30]="string\0string"; int i; strcpy(a,b); printf("strcpy():"); for(i=0;i<30;i++) printf("%c",a[i]); memcpy(a,b,30); printf("\nmemcpy() :"); for(i=0;i<30;i++) printf("%c",a[i]); }
执行	strcpy() : string a ) memcpy() : string string

memcpy实现：

void *memcpy(void *v_dst, const void *v_src, __kernel_size_t c)
{
    const char *src = v_src;
    char *dst = v_dst;
    while (c--)
        *dst++ = *src++;
    return v_dst;

}

memmove:

void * memmove(void *dest,const void *src,size_t n);返回赋值后的dest指针。

memmove(拷贝内存内容)
相关函数	bcopy，memccpy，memcpy，strcpy，strncpy
表头文件	#include<string.h>
定义函数	void * memmove(void dest,const void src,size_t n);
函数说明	memmove()与memcpy()一样都是用来拷贝src所指的内存内容前n个字节到dest所指的地址上。不同的是，当src和dest所指的内存区域重叠时，memmove()仍然可以正确的处理，不过执行效率上会比使用memcpy()略慢些。
返回值	返回指向dest的指针。
附加说明	其它的与memcpy一样，不同的是指针src和dest所指的内存区域可以重叠，若内存重叠，则从后往前复制。
范例	参考memcpy()。

memmove的实现：

void *memmove(void *v_dst, const void *v_src, __kernel_size_t c)
{
    const char *src = v_src;
    char *dst = v_dst;

    if (!c)  //都要先判断参数是否有效
        return v_dst;

    if (v_dst <= v_src) //memmove里面则判断了内存重叠的情况，当dest在src的后面时内存重叠，则从后往前复制，否则调用memcpy来实现就可以。
        return memcpy(v_dst, v_src, c);
    src += c;
    dst += c;
    while (c--)
        *--dst = *--src;
    //dest在src的后面时内存重叠，则从后往前复制
    return v_dst;

};

memccpy:

void *memccpy(void *dest, const void * src, int c,size_t n);返回指向dest中值为c的下一个字节指针。若没有返回值为0

memccpy(拷贝内存内容)
相关函数	bcopy，memcpy，memmove，strcpy，strncpy
表头文件	#include<string.h>
定义函数	void * memccpy(void dest, const void src, int c,size_t n);
函数说明	memccpy()用来拷贝src所指的内存内容前n个字节到dest所指的地址上。与memcpy()不同的是，memccpy()会在复制时检查参数c是否出现，若是则返回dest中值为c的下一个字节地址。
返回值	返回指向dest中值为c的下一个字节指针。返回值为0表示在src所指内存前n个字节中没有值为c的字节。
范例	#include<string.h> main() { char a[]="string[a]"; char b[]="string(b)"; memccpy(a,b,'B',sizeof(b)); printf("memccpy():%s\n",a); }
执行	memccpy():string(b)，返回0

strcpy、strncpy ------ 的原理其实并不是复制，而是覆盖。而没有被覆盖到的原字符串后面的字符仍然保留；

------还有就是：空间不重叠，即目的字符串的开头不能与源字符串的结尾重叠，而目的字符串的末尾与原字符串的开头重叠是可以的！！！

------ 若要做到用strncpy来实现字符串复制，则一定要在覆盖的末尾手动添加一个'\0'；而strcpy本身会自动将源字符串的末尾'\0'一起复制过去；

说明其实本身能实现字符串赋值的只有strcpy , 而其他的都是一段空间的覆盖。

strncpy:

char * strncpy(char *dest,const char *src,size_t n);返回参数dest的字符串起始地址。

strncpy 的效果和 memcpy相对字符串来说其实是一模一样的！！！

——size_t n 一定要注意它的值，最大不能超过(dest 的合法空间大小和src的合法空间)的最小值！！！

——不能空间重叠，即目的字符串的开头不能与源字符串的结尾重叠，而目的字符串的末尾与原字符串的开头重叠是可以的！！！

strncpy(拷贝字符串)
相关函数	bcopy，memccpy，memcpy，memmove
表头文件	#include<string.h>
定义函数	char * strncpy(char dest,const char src,size_t n);
函数说明	strncpy()会用参数src字符串的前n个字符，覆盖至参数dest所指的地址为起始地址的后n个字符空间，而至于后面没覆盖的空间并不会清空，而是保留原有值。
返回值	返回参数dest的字符串起始地址。
范例	#inclue <string.h> main() { char a[30]="string(1)"; char b[]="string(2)"; printf("before strncpy() : %s\n",a); printf("after strncpy() : %s\n",strncpy(a,b,6)); }
执行	before strncpy() : string(1) after strncpy() : string(1)

例子：——strncpy()实现的是覆盖，而至于目标后面没覆盖的空间并不会清空，而是保留原有值。若要实现字符串复制，则要手工添加'\0'；

main()
{
    int i;
     //strcpy 和 strncpy 都只是进行覆盖，后面没有覆盖到的值仍存在
    char gs[20];

    //?memset(gs,0,20)-----------数组若未初始化则要马上清零很重要，否则会有隐患
    printf("input a string:\n");
    gets(gs);
    printf("gs:%s\n", gs);
    for(i = 0; i < 20; i++)
        printf("%c", gs[i]); //后面的为乱码，说明gets并不会将后面的空值也赋为0，仅是前面的覆盖，所以说数组若未初始化则要马上清零是多么重要!
    printf("\n\n");

    strncpy(gs, gs + 3, strlen(gs + 3) - 2); //大小一定要控制好了，仅是将中间的一部分字符串覆盖到开头------若是只想达到覆盖的效果，这样就可以了
    gs[strlen(gs + 3) - 2] = '\0';
    //若是想做的不是覆盖而是复制字符串，则一定要格外添加'\0'
    printf("gs:%s\n", gs);
    
    for(i = 0; i < 20; i++) //strcpy 和 strncpy 都只是进行覆盖，后面没有覆盖到的值仍存在
        printf("%c", gs[i]); //后面的为乱码，说明gets并不会将后面的空值也赋为0，仅是前面的覆盖，所以说数组若未初始化则要马上清零是多么重要!
    printf("\n");

}

输出：

input a string:
123456789
gs:123456789
123456789�U̶Y� //输出gs[i]
gs:4567 //输出手动补'\0'后的strncpy
45676789�U̶Y� //输出gs[i]

例子——size_t n 一定要注意它的值，最大不能超过(dest 的合法空间大小和src的合法空间)的最小值！！！

main()
{
    int i;
   
    char gs[10], ks[20];
    printf("input gs[10]:\n");
    gets(gs);
    //输入gs[10]
    printf("gs:%s\n", gs);
    printf("input ks[20]:\n");
    gets(ks);
   //输入ks[20]
    printf("ks:%s\n", ks);
    for(i = 0; i < 10; i++)
        printf("%c", gs[i]);
    printf("\n");
    for(i = 0; i < 10; i++)
        printf("%c", gs[i]);
    printf("\n\n");

    strncpy(gs + 3, ks, 20); //溢出了——改变了非法空间的内容，会造成不可预料的结果，甚至是程序崩溃
    (gs + 3)[20] = '\0';
    //若是想做的不是覆盖而是复制字符串，则一定要格外添加'\0'

    printf("gs+3:%s\n", gs);
    
    for(i = 3; i < 20; i++)
        printf("%c", gs[i]);
    printf("\n");

}

结果：程序崩溃！！

例子——不能空间重叠，即目的字符串的开头不能与源字符串的结尾重叠，而目的字符串的末尾与原字符串的开头重叠是可以的！！！

strcpy:

strcpy——实现的真的是一个字符串复制，不过还要考虑源字符串与目的字符串合法空间的大小关系，而且一定要遵守的是不能实现空间重叠；

char *strcpy(char *dest,const char *src);返回参数dest的字符串起始地址。

strcpy(拷贝字符串)
相关函数	bcopy，memcpy，memccpy，memmove
表头文件	#include<string.h>
定义函数	char strcpy(char dest,const char *src);
函数说明	strcpy()会将参数src字符串拷贝至参数dest所指的地址。
返回值	返回参数dest的字符串起始地址。
附加说明	如果参数dest所指的内存空间不够大，可能会造成缓冲溢出(buffer Overflow)的错误情况，在编写程序时请特别留意，或者用strncpy()来取代。
范例	#include<string.h> main() { char a[30]="string(1)"; char b[]="string(2)"; printf("before strcpy() :%s\n",a); printf("after strcpy() :%s\n",strcpy(a,b)); }
执行	before strcpy() :string(1) after strcpy() :string(2)

strncat:

第一个参数dest要有足够的空间来容纳要拷贝的字符串-----否则会造成溢出，结果不可预知

char * strncat(char *dest,const char *src,size_t n);返回参数dest的字符串起始地址。

strncat(连接两字符串)
相关函数	bcopy，memccpy，memecpy，strcpy，strncpy
表头文件	#inclue <string.h>
定义函数	char * strncat(char dest,const char src,size_t n);
函数说明	strncat()会将参数src字符串拷贝n个字符到参数dest所指的字符串尾。第一个参数dest要有足够的空间来容纳要拷贝的字符串。
返回值	返回参数dest的字符串起始地址。
范例	#include <string.h> main() { char a[30]="string(1)"; char b[]="string(2)"; printf("before strnact() :%s\n", a); printf("after strncat() :%s\n", strncat(a,b,6)); }
执行	before strnact() : string(1) after strncat() : string(1) string

strncat 的实现：

char *strncat(char *dest, const char *src, size_t n)
{
    char *dt = dest;

    const char *sc = src;

    if (dest == NULL || source == NULL) ?

    {
        ? ?? ? ? ?? ? printf("the input string is error!\n");
        return NULL;
        ?
    }

    ? while (*dt++ != '\0') ?
        ;
    dt--;
    ? //为了弥补等于'\0'后的还dest++

    while (n--)
        *dt++ = *sc++;
    return ? dest;
}

strcat:

strcat(连接两字符串)
相关函数	bcopy，memccpy，memcpy，strcpy，strncpy
表头文件	#include <string.h>
定义函数	char strcat (char dest,const char *src);
函数说明	strcat()会将参数src字符串拷贝到参数dest所指的字符串尾。第一个参数dest要有足够的空间来容纳要拷贝的字符串。
返回值	返回参数dest的字符串起始地址
范例	#include <string.h.> main() { char a[30]="string(1)"; char b[]="string(2)"; printf("before strcat() : %s\n",a); printf("after strcat() : %s\n",strcat(a,b)); }
执行	before strcat () : string(1) after strcat () : string(1)string(2)

strcat 的实现：

char *strcat(char *dest, const char *src)
{
    char *dt = dest;

    const char *sc = src;

    if (dest == NULL || source == NULL) ?

    {
        ? ?? ? ? ?? ? printf("the input string is error!\n");
        return NULL;
        ?
    }

    ? while (*dt++ != '\0') ?
        ;
    dt--;
    ? //为了弥补等于'\0'后的还dest++

    while (*dt++ = *sc++)
        ;
    return dest;
}

strdup:

该函数并不是完成如strncpy、strncpy、strcpy那样在已有的字符串空间进行覆盖，而是实实在在的字符串空间的一份拷贝，生成另一个实体，然后返回给一个无指向指针；

strdup(复制字符串)
相关函数	calloc，malloc，realloc，free
表头文件	#include<string.h>
定义函数	char * strdup( const char *s);
函数说明	strdup()会先用malloc()配置与参数s字符串相同的空间大小，然后将参数s字符串的内容复制到该内存地址，然后把该地址返回。该地址最后可以利用free()来释放。
返回值	返回一字符串指针，该指针指向复制后的新字符串地址。若返回NULL表示内存不足。
范例	#include<string.h> main() { char a[]="strdup"; char *b; b=strdup(a); printf("b[ ]=\"%s\"\n",b); }
执行	b[ ]="strdup"

strdup的实现：

====================================================================================================================================

查找：

查找：memchr 、strchr 、strrchr -- 3 字符查找：返回第一次查找到的地址

查找：index、rindex -- 2 字符查找：返回最后一次查找到的地址

查找： strstr --1 字符串查找：返回第一次查找到的地址

memchr:

void * memchr(const void *s,int c,size_t n);

memchr(在某一内存范围中查找一特定字符)
相关函数	index，rindex，strchr，strpbrk，strrchr，strsep，strspn，strstr
表头文件	#include<string.h>
定义函数	void * memchr(const void *s,int c,size_t n);
函数说明	memchr()从头开始搜寻s所指的内存内容前n个字节，直到发现第一个值为c的字节，则返回指向该字节的指针。
返回值	如果找到指定的字节则返回该字节的指针，否则返回0。
范例	#include <string.h> main() { char s="0123456789012345678901234567890"; char p; p=memchr(s,'5',10); printf("%p\n",p); }
执行	5.68E+25

strchr:

char * strchr (const char *s,int c);

strchr(查找字符串中第一个出现的指定字符)
相关函数	index，memchr，rinex，strbrk，strsep，strspn，strstr，strtok
表头文件	#include<string.h>
定义函数	char * strchr (const char *s,int c);
函数说明	strchr()用来找出参数s字符串中第一个出现的参数c地址，然后将该字符出现的地址返回。
返回值	如果找到指定的字符则返回该字符所在地址，否则返回0。
范例	#include<string.h> main() { char s=0123456789012345678901234567890”; char p; p=strchr(s,'5'); printf("%p\n",p); }
执行	5.68E+25

index:

index(查找字符串中第一个出现的指定字符)
相关函数	rindex，srechr，strrchr
表头文件	#include<string.h>
定义函数	char * index( const char *s, int c);
函数说明	index()用来找出参数s字符串中第一个出现的参数c地址，然后将该字符出现的地址返回。字符串结束字符(NULL)也视为字符串一部分。
返回值	如果找到指定的字符则返回该字符所在地址，否则返回0。
范例	#include<string.h> main() { char s =”0123456789012345678901234567890”; char p; p =index(s,’5’); printf(%s\n”,p); }
执行	5.68E+25

strrchr:

strrchr(查找字符串中最后出现的指定字符)
相关函数	index，memchr，rindex，strpbrk，strsep，strspn，strstr，strtok
表头文件	#include<string.h>
定义函数	char * strrchr(const char *s, int c);
函数说明	strrchr()用来找出参数s字符串中最后一个出现的参数c地址，然后将该字符出现的地址返回。
返回值	如果找到指定的字符则返回该字符所在地址，否则返回0。
范例	#include<string.h> main() { char s="0123456789012345678901234567890"; char p; p=strrchr(s,'5'); printf("%p\n",p); }
执行	567890

rindex:

rindex(查找字符串中最后一个出现的指定字符)
相关函数	index，memchr，strchr，strrchr
表头文件	#include<string.h>
定义函数	char * rindex( const char *s,int c);
函数说明	rindex()用来找出参数s字符串中最后一个出现的参数c地址，然后将该字符出现的地址返回。字符串结束字符(NULL)也视为字符串一部分。
返回值	如果找到指定的字符则返回该字符所在的地址，否则返回0。
范例	#include <string.h> mian() { char s ="0123456789012345678901234567890"; char p; p=rindex(s,'5'); printf("%p\n",p); }
执行	567890

strstr:

strstr(在一字符串中查找指定的字符串)
相关函数	index，memchr，rindex，strchr，strpbrk，strsep，strspn，strtok
表头文件	#include<string.h>
定义函数	char strstr(const char haystack,const char *needle);
函数说明	strstr()会从字符串haystack 中搜寻字符串needle，并将第一次出现的地址返回。
返回值	返回指定字符串第一次出现的地址，否则返回0。
范例	#include<string.h> main() { char * s="012345678901234567890123456789"; char *p; p= strstr(s,"901"); printf("%s\n",p); }
执行	9.01E+21

strstr的实现：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
const char *mystrstr(const char *dest, const char *search);
main()
{
    char str[30], fstr[10];
    const char *finds;
    printf("input a string str[20]:\n");
    gets(str);


    printf("input a string str[20]:\n");
    gets(fstr);


    printf("search %s in %s :\n", str, fstr);
    finds = mystrstr(str, fstr);
    if(finds)
        printf("find ! in %d :%.*s\n", finds - str, strlen(fstr), finds);
    else
        printf("no find !\n");
}


const char *mystrstr(const char *dest, const char *search)
{
    const char *dst = dest;
    const char *sch = search;
    int i;
    if(dest == NULL || search == NULL)
    {
        printf("the string be NULL\n");
        return NULL;
    }

    while(*dst)
    {
        if(!strncmp(dst, sch, strlen(sch)))
            return dst;
        dst++;
    }

    return NULL;
}

输出：

input a string str[20]:
abcd 123 abcd m 12 m hj123 m
input a string str[20]:
12 m
search abcd 123 abcd m 12 m hj123 m in 12 m :
find ! in 16 :12 m

strcspn:

strcspn(返回字符串中连续不含指定字符串内容的字符数)
相关函数	strspn
表头文件	#inclued<string.h>
定义函数	size_t strcspn ( const char s,const char reject);
函数说明	strcspn()从参数s字符串的开头计算连续的字符，而这些字符都完全不在参数reject 所指的字符串中。简单地说，若strcspn()返回的数值为n，则代表字符串s开头连续有n个字符都不含字符串reject内的字符。
返回值	返回字符串s开头连续不含字符串reject内的字符数目。
范例	#include <string.h> main() { char *str="Linux was first developed for 386/486-based pcs."; printf("%d\n",strcspn(str," ")); printf("%d\n",strcspn(str,"/-")); printf("%d\n",strcspn(str,"1234567890")); }
执行	5 /只计算到“ ”的出现，所以返回“Linux”的长度/ 33 /计算到出现“/”或“－”，所以返回到“6”的长度/ 30 /* 计算到出现数字字符为止，所以返回“3”出现前的长度*/

strspn:

strspn(返回字符串中连续不含指定字符串内容的字符数)
相关函数	strcspn，strchr，strpbrk，strsep，strstr
表头文件	#include<string.h>
定义函数	size_t strspn (const char s,const char accept);
函数说明	strspn()从参数s 字符串的开头计算连续的字符，而这些字符都完全是accept 所指字符串中的字符。简单的说，若strspn()返回的数值为n，则代表字符串s 开头连续有n 个字符都是属于字符串accept内的字符。
返回值	返回字符串s开头连续包含字符串accept内的字符数目。
范例	#include<string.h> main() { char str="Linux was first developed for 386/486-based PCs."; char t1="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; printf("%d\n",strspn(str,t1)); }
执行	5 /计算大小写字母。不包含“ ”，所以返回Linux的长度。/

====================================================================================================================================

比较：

memcmp、strcmp、strncasecmp、strcasecmp

(有n、无n)分大小写母，小写大于大写 (有n、无n)不分大小写，小写等于大写

memcmp:

int memcmp (const void *s1,const void *s2,size_tn);

memcmp(比较内存内容)
相关函数	bcmp，strcasecmp，strcmp，strcoll，strncmp，strncasecmp
表头文件	#include<string.h>
定义函数	int memcmp (const void s1,const void s2,size_t n);
函数说明	memcmp()用来比较s1和s2所指的内存区间前n个字符。字符串大小的比较是以ASCII码表上的顺序来决定，次顺序亦为字符的值。memcmp()首先将s1第一个字符值减去s2第一个字符的值，若差为0则再继续比较下个字符，若差值不为0则将差值返回。例如，字符串"Ac"和"ba"比较则会返回字符'A'(65)和'b'(98)的差值(－33)。
返回值	若参数s1和s2所指的内存内容都完全相同则返回0值。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0的值。
范例	#include<string.h> main() { char a ="aBcDeF"; char b="AbCdEf"; char c="aacdef"; char d="aBcDeF"; printf("memcmp(a,b):%d\n",memcmp((void)a,(void) b,6)); printf("memcmp(a,c):%d\n",memcmp((void)a,(void) c,6)); printf("memcmp(a,d):%d\n",memcmp((void)a,(void) d,6));
执行	memcmp(a,b):1 /字符串a > 字符串b，返回 1/ memcmp(a,c):-1 /字符串a < 字符串c, 返回－1/ memcmp(a,d):0 /字符串a ＝字符串d，返回 0/

mymemcmp的实现：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int mymemcmp(const void *s1, const void *s2, size_t n);
main()
{
    char str1[20];
    char str2[20];
    int flag, n;
    printf("input a string[20]:\n");
    gets(str1);
    printf("input a string[20]:\n");
    gets(str2);
    n = strlen(str1) < strlen(str2) ? strlen(str1) : strlen(str1) == strlen(str2) ? strlen(str1) : strlen(str2);
    flag = mymemcmp(str1, str2, n);
    if(flag < 0)
        printf("memory : %.*s lower than %.*s\n", n, str1, n, str2);
    else if(flag > 0)
        printf("memory : %.*s ?upper than %.*s\n", n, str1, n, str2);
    else
        printf("memory : %.*s ?equel to %.*s\n", n, str1, n, str2);
}

int mymemcmp(const void *s1, const void *s2, size_t n) ?//对内存的操作，void *一定要转为 char *来操作 ！！！
{
    const char *p1 = s1;
    const char *p2 = s2;

    if(s1 == NULL || s2 == NULL)
    {
        printf("the address be NULL\n");
        return 0;
    }

    while(n--)
    {
        if(*p1 != *p2)
            return *p1 > *p2 ? 1 : -1;
        p1++;
        p2++;
    }

    return 0;

}

strcmp:

int strcmp(const char *s1,const char *s2);

strcmp(比较字符串)
相关函数	bcmp，memcmp，strcasecmp，strncasecmp，strcoll
表头文件	#include<string.h>
定义函数	int strcmp(const char s1,const char s2);
函数说明	strcmp()用来比较参数s1和s2字符串。字符串大小的比较是以ASCII 码表上的顺序来决定，此顺序亦为字符的值。strcmp()首先将s1第一个字符值减去s2第一个字符值，若差值为0则再继续比较下个字符，若差值不为0则将差值返回。例如字符串"Ac"和"ba"比较则会返回字符"A"(65)和'b'(98)的差值(－33)。
返回值	若参数s1和s2字符串相同则返回0。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0 的值。
范例	#include<string.h> main() { char a="aBcDeF"; char b="AbCdEf"; char c="aacdef"; char d="aBcDeF"; printf("strcmp(a,b) : %d\n",strcmp(a,b)); printf("strcmp(a,c) : %d\n",strcmp(a,c)); printf("strcmp(a,d) : %d\n",strcmp(a,d)); }
执行	strcmp(a,b) : 32 strcmp(a,c) :-31 strcmp(a,d) : 0

strcmp的实现：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int mystrcmp(const char *str1, const char *str2);
main()
{
    char str1[20];
    char str2[20];
    int flag;
    printf("input a string[20]:\n");
    gets(str1);
    printf("input a string[20]:\n");
    gets(str2);
    flag = mystrcmp(str1, str2);
    if(flag < 0)
        printf("%s lower than %s\n", str1, str2);
    else if(flag > 0)
        printf("%s ?upper than %s\n", str1, str2);
    else
        printf("%s ?equel to %s\n", str1, str2);
}

int mystrcmp(const char *str1, const char *str2)
{
    const char *p1 = str1;
    const char *p2 = str2;

    if(str1 == NULL || str2 == NULL)
    {
        printf("the string be NULL\n");
        return 0;
    }

    while(*p1 || *p2)
    {
        if(*p1 != *p2)
            return *p1 > *p2 ? 1 : -1;
        p1++;
        p2++;
    }
    if(*p1 != *p2) //因为有一个为'\0' = 0 ,这是为了判断哪一个为'\0' 哪一个不为'\0' ,这样就能判断出长度谁长了
        return *p1 > *p2 ? 1 : -1;
    return 0;
}

strncasecmp:

int strncasecmp(const char *s1,const char *s2,size_tn);

strncasecmp(忽略大小写比较字符串)
相关函数	bcmp，memcmp，strcmp，strcoll，strncmp
表头文件	#include<string.h>
定义函数	int strncasecmp(const char s1,const char s2,size_t n);
函数说明	strncasecmp()用来比较参数s1和s2字符串前n个字符，比较时会自动忽略大小写的差异。
返回值	若参数s1和s2 字符串相同则返回0。s1 若大于s2则返回大于0的值，s1若小于s2则返回小于0 的值。
范例	#include<string.h> main() { char a="aBcDeF"; char b="AbCdEf"; if(!strncasecmp(a,b)) printf("%s =%s\n",a,b); }
执行	aBcDef=AbCdEf

strcasecmp:

int strcasecmp (const char *s1, const char *s2);

strcasecmp(忽略大小写比较字符串)
相关函数	bcmp，memcmp，strcmp，strcoll，strncmp
表头文件	#include<string.h>
定义函数	int strcasecmp (const char s1, const char s2);
函数说明	strcasecmp()用来比较参数s1和s2字符串，比较时会自动忽略大小写的差异。
返回值	若参数s1和s2字符串相同则返回0。s1长度大于s2长度则返回大于0 的值，s1 长度若小于s2 长度则返回小于0的值。
范例	#include <string.h> main() { char a="aBcDeF"; char b="AbCdEf"; if(!strcasecmp(a,b)) printf("%s=%s\n",a,b); }
执行	aBcDeF=AbCdEf

====================================================================================================================================

切割：

strtok:

strtok(分割字符串)
相关函数	index，memchr，rindex，strpbrk，strsep，strspn，strstr
表头文件	#include<string.h>
定义函数	char * strtok(char s,const char delim);
函数说明	strtok()用来将字符串分割成一个个片段。参数s指向欲分割的字符串，参数delim则为分割字符串，当strtok()在参数s的字符串中发现到参数delim的分割字符时则会将该字符改为\0 字符。在第一次调用时，strtok()必需给予参数s字符串，往后的调用则将参数s设置成NULL。每次调用成功则返回下一个分割后的字符串指针。若是字符串中若是没有存在分割字符，则返回整个字符串；即strtok实现二分字符串，用char delim里头的任意字符作为分隔字符，当 char s遇到delim中的字符时，此字符就变为“分隔刀”,将前一半字符串首地址返回，将后一半字符串赋给char s ，char s有提供记忆功能，除非重新被赋为一个有效值，否则记录的是上一次切割下来的剩下的那段字符串的首地址。也就是说若要将一字符串string分隔成两串字符串并得到，则要strtok两次，并且后一次的strtok的char *s不赋新值，用NULL代替。
返回值	返回下一个分割后的字符串指针，如果已无从分割则返回NULL。
范例	#include<string.h> main() { char s[]="ab-cd : ef;gh :i-jkl;mnop;qrs-tu: vwx-y;z"; char delim="-: "; char p; printf("%s ",strtok(s,delim)); while((p=strtok(NULL,delim)))printf("%s ",p); printf("\n"); }
执行	ab cd ef;gh i jkl;mnop;qrs tu vwx y;z /－与:字符已经被\0 字符取代

mystrtok的实现：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char *mystrtok(char *s, const char *delim);
main()
{
    char s1[30], s2[30], finds[5];
    char *p = NULL;
    printf("input a string[30]:\n");
    gets(s1);
    strcpy(s2, s1);
    printf("input a string[10]:\n");
    gets(finds);
    printf("use \"%s\" cut \"%s\" :\n", finds, s1);

    printf("%s ", strtok(s1, finds));
    while((p = strtok(NULL, finds)))printf("%s ", p);
    printf("\n");

    printf("%s ", mystrtok(s2, finds));
    while((p = mystrtok(NULL, finds)))printf("%s ", p);
    printf("\n");
}
char *mystrtok(char *s, const char *delim)
{
    static char *sp;
    const char *dep = delim;
    int cut_flag = 0;
    if(s != NULL)
        sp = s;
    //第一次分割
    else
        s = sp;
    //继承前一次的分割
    //若上次的分割刚好最后一个字符为分割字符，则此次的sp 指向的就是上一次字符串的末尾结束符'\0'
    //那么就不该让它继续
    if(!strlen(sp))
        return NULL;
    while(*sp)
    {
        while(*dep)
        {
            if(*dep == *sp)
            {
                *sp = '\0';
                sp++;
                cut_flag = 1;
                break;
            }
            dep++;
        }
        dep = delim;
        if(((sp - s) == 1) && cut_flag)   //处理首字符就是切割字符的情况
        {
            s++;
            cut_flag = 0;
            continue;
        }
        else if(cut_flag)
            break;
        else
            sp++;
    }
    return s;

}