字符串函数整理

#define  _CRT_SECURE_NO_WARNINGS 
#include "stdlib.h"
#include "string.h"
#include "stdio.h"


//01 strcpy
//原型声明：char *strcpy(char* dest, const char *src);
//头文件：#include <string.h> 和 #include <stdio.h>
//功能：把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间
//说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
//返回指向dest的指针。
void test_strcpy(void)
{
	//char *dest = "1234567890";  字面值常量 不能被修改
	char dest[] = "1234567890";
	char *src = "abcdefg";

	char *p1 = NULL;

	p1 = (char *)malloc(100);
	printf("src: %s\n", src);
	printf("dest: %s\n", dest);
	printf("p1: %s\n", p1);

	printf("----------------------------\n");
	p1 = strcpy(dest, src);
	printf("src: %s\n", src);
	printf("dest: %s\n", dest);
	printf("p1: %s\n", p1);
}

//02 strncpy
//函数原型char *strncpy(char *dest, char *src, size_t n);
/*（c / c++）复制字符串src中的内容（字符，数字、汉字....）
到字符串dest中，复制多少由size_t n的值决定。如果src的
前n个字符不含NULL字符，则结果不会以NULL字符结束。
如果n<src的长度，只是将src的前n个字符复制到dest的前n个字符，
不自动添加'\0'，也就是结果dest不包括'\0'，需要再手动添加一个'\0'。
如果src的长度小于n个字节，则以NULL填充dest直到复制完n个字节。
src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳
src的字符长度 + '\0'。*/
void test_strncpy(void)
{
	//char *dest = "1234567890";  字面值常量 不能被修改
	//char dest[] = "1234567890";自动分配 当比n小的时候中断错误
	char dest[100] = "1234567890";
	char *src = "abcdefg";

	char *p1 = NULL;

	p1 = (char *)malloc(100);
	printf("strlen(dest): %d\n", strlen(dest));
	printf("src: %s\n", src);
	printf("dest: %s\n", dest);
	printf("p1: %s\n", p1);

	printf("----------------------------\n");
	p1 = strncpy(dest, src,20);
	printf("strlen(dest): %d\n", strlen(dest));
	printf("src: %s\n", src);
	printf("dest: %s\n", dest);
	printf("p1: %s\n", p1);
}

//03 strcat
//extern char *strcat(char *dest, const char *src);
//头文件
//在C中，函数原型存在 <string.h>头文件中。
//在C++中，则存在于<cstring>头文件中。
//功能
//把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')。
//说明
//src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
//返回指向dest的指针
void test_strcat(void)
{
	//char *dest = "1234567890";  字面值常量 不能被修改
	//char dest[] = "1234567890";自动分配 当比n小的时候中断错误
	char dest[100] = "1234567890";
	char *src = "abcdefg";

	char *p1 = NULL;

	p1 = (char *)malloc(100);
	printf("strlen(dest): %d\n", strlen(dest));
	printf("src: %s\n", src);
	printf("dest: %s\n", dest);
	printf("p1: %s\n", p1);

	printf("----------------------------\n");
	p1 = strcat(dest, src);
	printf("strlen(dest): %d\n", strlen(dest));
	printf("src: %s\n", src);
	printf("dest: %s\n", dest);
	printf("p1: %s\n", p1);
}

//04 strchr
/*char *strchr(const char* _Str, char _Val)
char *strchr(char* _Str, char _Ch)
头文件：#include <string.h>
功能：查找字符串_Str中首次出现字符_Val的位置
说明：返回首次出现_Val的位置的指针，返回的地址是被查找字符串指针开始的
第一个与Val相同字符的指针，如果Str中不存在Val则返回NULL。
返回值：成功则返回要查找字符第一次出现的位置，失败返回NULL*/
void test_strchr(void)
{
	char *dest = "abnsdfmsdfjl";  //字面值常量 不能被修改
	//char dest[] = "1234567890";自动分配 当比n小的时候中断错误
	//char dest[100] = "1234567890";
	char *src = "sd";

	char *p1 = NULL;

	p1 = (char *)malloc(100);
	printf("strlen(dest): %d\n", strlen(dest));
	printf("src: %s\n", src);
	printf("dest: %s\n", dest);
	printf("p1: %s\n", p1);

	printf("----------------------------\n");
	p1 = strchr(dest, src);
	printf("strlen(dest): %d\n", strlen(dest));
	printf("src: %s\n", src);
	printf("dest: %s\n", dest);
	printf("p1: %s\n", p1);
}

//05	strcmp
/*当s1<s2时，返回为负数；
	当s1 == s2时，返回值 = 0；
	当s1>s2时，返回正数。
	即：两个字符串自左向右逐个字符相比（按ASCII值大小相比较），
	直到出现不同的字符或遇'\0'为止*/
void test_strcmp(void)
{
	int value4 = 0;
	int value1 = 0;
	int value2 = 0;
	int value3 = 0;
	int value5 = 0;
	char *p1 = "abcdefg";
	char *p2 = "abcdefgh";
	char *p3 = "abcjefgh";
	char *p4 = "abcaefgh";
	char *p5 = "abc1efgh";
	char *p6 = "abcdefg";

	value1 = strcmp(p1, p2);
	value2 = strcmp(p2, p3);
	value3 = strcmp(p2, p4);
	value4 = strcmp(p2, p5);
	value5 = strcmp(p1, p6);

	printf("value1: %d\n",value1);
	printf("value2: %d\n", value2);
	printf("value3: %d\n", value3);
	printf("value4: %d\n", value4);
	printf("value5: %d\n", value5);
}

//06 strnicmp 
//nt strnicmp(char *str1, char *str2, unsigned maxlen);
/*功 能： 比较字符串str1和str2的前n个字符串字典序的大小，但是不区分字母大小写。
返回值： 当str1<str2时，返回值是-1 ; 
当str1=str2时，返回值是0; 
当str1>str2时，返回值是1。
比较是这样进行的，先比较两个字符串的第1个字符字典序的大小，
如果能比较出大小，则马上返回了，如果不能区别大小，开始比较第2个，
如果这时第1个字符串已经到尽头了，第2个字符串还有字符，
这时算第2个字符串大。*/
/*void test_strnicmp(void)
{
	int value4 = 0;
	int value1 = 0;
	int value2 = 0;
	int value3 = 0;
	int value5 = 0;
	char *p1 = "abcdefgh";
	char *p2 = "abcdefgh";
	char *p3 = "abcjefgh";
	char *p4 = "abcaefgh";
	char *p5 = "abc1efgh";
	char *p6 = "abCdeFgh";

	value1 = strncmpi(p1, p2,7);
	value2 = strnicmp(p2, p3,7);
	value3 = strnicmp(p2, p4,7);
	value4 = strnicmp(p2, p5,7);
	value5 = strnicmp(p1, p6,7);

	printf("value1: %d\n", value1);
	printf("value2: %d\n", value2);
	printf("value3: %d\n", value3);
	printf("value4: %d\n", value4);
	printf("value5: %d\n", value5);
}*/

//07 strlrn
//extern unsigned int strlen(char *s);
/*strlen所作的仅仅是一个计数器的工作，
它从内存的某个位置（可以是字符串开头，
中间某个位置，甚至是某个不确定的内存区域）
开始扫描，直到碰到第一个字符串结束符'\0'为止，
然后返回计数器值(长度不包含'\0')。*/
void test_strlen(void)
{
	char *p1 = "abcdfghtdvfc csfsc  vfysdg";//26
	printf("strlen(p1): %d\n",strlen(p1));
}

//08 strcspn 
//：size_t strcspn(const char *s, const char * reject)
/*函数说明：strcspn()从参数s 字符串的开头计算连续的字符，
而这些字符都完全不在参数reject 所指的字符串中。简单地说，
若strcspn()返回的数值为n，则代表字符串s 开头连续有n 个字符
都不含字符串reject 内的字符。
返回值：返回字符串s 开头连续不含字符串reject 内的字符数目。*/
void test_strcspn(void)
{
	char *p1 = "abcdfghtdvfc csfsc  vfysdg";//26
	int t = 0;
	t = strcspn(p1,"cd");//2
	printf("t: %d\n", t);
}

//09 strdup
//extern char *strdup(char *s);
/*功 能: 将串拷贝到新建的位置处
strdup()在内部调用了malloc()为变量分配内存，
不需要使用返回的字符串时，需要用free()释放相应的内存空间，
否则会造成内存泄漏。
返回值：
返回一个指针,指向为复制字符串分配的空间;如果分配空间失败,则返回NULL值。*/
/*void test_strdup(void)
{
	char *p = NULL;

	p = strdup("abcdefg");
	printf("p: %s\n", p);
}*/

// 10 stricmp
/*功能：比较字符串s1和s2，但不区分字母的大小写。
说明：strcmpi是到stricmp的宏定义，实际未提供此函数。
当s1<s2时，返回值<0
当s1 = s2时，返回值 = 0
当s1>s2时，返回值>0 */
/*void test_stricmp(void)
{
	int value4 = 0;
	int value1 = 0;
	int value2 = 0;
	int value3 = 0;
	int value5 = 0;
	char *p1 = "abcdefgh";
	char *p2 = "abcdefgh";
	char *p3 = "abcjefgh";
	char *p4 = "abcaefgh";
	char *p5 = "abc1efgh";
	char *p6 = "abCdeFgh";

	value1 = strcmpi(p1, p2);
	value2 = strcmpi(p2, p3);
	value3 = strcmpi(p2, p4);
	value4 = strcmpi(p2, p5);
	value5 = strcmpi(p1, p6);

	printf("value1: %d\n", value1);
	printf("value2: %d\n", value2);
	printf("value3: %d\n", value3);
	printf("value4: %d\n", value4);
	printf("value5: %d\n", value5);
}*/

//11 strerror
//通过标准错误的标号，获得错误的描述字符串 ，
//将单纯的错误标号转为字符串描述，方便用户查找错误。

//12 strcmpi
//同10

//13 strncmp
//int strncmp(const char * str1, const char * str2, size_t n);
/*【参数】str1, str2 为需要比较的两个字符串，n为要比较的字符的数目。
字符串大小的比较是以ASCII 码表上的顺序来决定，此顺序亦为字符的值。
strncmp()首先将s1 第一个字符值减去s2 第一个字符值，若差值为0 
则再继续比较下个字符，直到字符结束标志'\0'，若差值不为0，则将差值返回。
例如字符串"Ac"和"ba"比较则会返回字符"A"(65)和'b'(98)的差值(-33)。
注意：要比较的字符包括字符串结束标志'\0'，而且一旦遇到'\0'就结束比较，
无论n是多少，不再继续比较后边的字符。
【返回值】若str1与str2的前n个字符相同，则返回0；若s1大于s2，
则返回大于0的值；若s1 若小于s2，则返回小于0的值。*/
void test_strncmp(void)
{
	int value4 = 0;
	int value1 = 0;
	int value2 = 0;
	int value3 = 0;
	int value5 = 0;
	char *p1 = "abcdefgh";
	char *p2 = "abcdefgh";
	char *p3 = "abcjefgh";
	char *p4 = "abcaefgh";
	char *p5 = "abc1efgh";
	char *p6 = "abCdeFgh";

	value1 = strncmp(p1, p2,7);
	value2 = strncmp(p2, p3,3);
	value3 = strncmp(p2, p4,3);
	value4 = strncmp(p2, p4,4);
	value5 = strncmp(p1, p6,7);

	printf("value1: %d\n", value1);
	printf("value2: %d\n", value2);
	printf("value3: %d\n", value3);
	printf("value4: %d\n", value4);
	printf("value5: %d\n", value5);
}

//14 strncpy 
//char *strncpy(char *dest,char *src,size_t n);
/*（c/c++）复制字符串src中的内容（字符，数字、汉字....）
到字符串dest中，复制多少由size_t n的值决定。
如果src的前n个字符不含NULL字符，则结果不会以NULL字符结束。
如果n<src的长度，只是将src的前n个字符复制到dest的前n个字符，
不自动添加'\0'，也就是结果dest不包括'\0'，需要再手动添加一个'\0'。
如果src的长度小于n个字节，则以NULL填充dest直到复制完n个字节。
src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的
字符长度+'\0'。*/

//15 strnicmp 
/*功 能： 比较字符串str1和str2的前n个字符串字典序的大小，但是不区分字母大小写。
返回值： 当str1<str2时，返回值是 - 1;
当str1 = str2时，返回值是0; 
当str1>str2时，返回值是1。
比较是这样进行的，先比较两个字符串的第1个字符字典序的大小，
如果能比较出大小，则马上返回了，如果不能区别大小，开始比较第2个，
如果这时第1个字符串已经到尽头了，第2个字符串还有字符，这时算第2个字符串大。*/

//16  strnset
//char*strnset(char*str, char ch, unsigned n);
//功 能 : 将一个字符串中的前n个字符都设为指定字符ch
/*void test_strnset(void)
{
	char p1[100];
	char p2[100];
	char *p3 = "a";
//	strnset(p1,p3,10);
	strset(p2, p3);
	printf("p1: %s\n", p1);
	printf("p2: %s\n", p2);
}*/

//17 strpbrk 
//extern char *strpbrk(const char *s1, const char *s2);
/*依次检验字符串s1中的字符，当被检验字符在字符串s2中也包含时，则停止检验，
并返回该字符位置，空字符null不包括在内。
返回s1中第一个满足条件的字符的指针，如果没有匹配字符则返回空指针NULL。
在源字符串（s1）中找出最先含有搜索字符串（s2）中任一字符的位置并返回，
若找不到则返回空指针。*/
void test_strpbrk()
{
	char *p1 = "abcdefg";
	char *p2 = "yuope";
	char *p3 = NULL;
	p3 = strpbrk(p1,p2);
	printf("p3: %s\n", p3);
}

//18 strrchr
//char *strrchr(const char *str, char c);
/*查找一个字符c在另一个字符串str中末次出现的位置
（也就是从str的右侧开始查找字符c首次出现的位置），
并返回这个位置的地址。如果未能找到指定字符，
那么函数将返回NULL。使用这个地址返回从最后一个字符c到str末尾的字符串。*/
void test_strrchr()
{
	char *p1 = "abcadaefg";
	char *p2 = NULL;
	p2 = strrchr(p1,'a');
	printf("p2: %s\n", p2);
}

//19 strrev
//extern char *strrev(char *s);
//功能：把字符串s的所有字符的顺序颠倒过来（不包括空字符NULL）。
//说明：返回指向颠倒顺序后的字符串指针。
/*
void test_strrev()
{
	char p1[] = "abcdefg";
	strrev(p1);
}*/

//20 strspn（返回字符串中第一个不在指定字符串中出现的字符下标）
//size_t strspn(const char *s, const char * accept);
/*函数说明 strspn()从参数s 字符串的开头计算连续的字符，
而这些字符都完全是accept 所指字符串中的字符。简单的说，
若strspn()返回的数值为n，则代表字符串s 开头连续有n 个字符
都是属于字符串accept内的字符。
返回值 返回字符串s开头连续包含字符串accept内的字符数目。*/
void test_strspn()
{
	char *p1 = "abcdefghijklmn";
	char *p2 = "rtyhretgdfbeac";
	int t = 0;
	t = strspn(p1,p2);
	printf("t: %d\n", t);
}

//21 strstr 
/*strstr(str1, str2) 函数用于判断字符串str2是否是str1的子串。
如果是，则该函数返回str2在str1中首次出现的地址；否则，返回NULL。*/
void test_strstr()
{
	char *p1 = "abcdegfsdfcgfdf";
	char *p2 = "sdf";
	char *p3 = NULL;
	p3 = strstr(p1,p2);
	printf("p3: %s\n", p3);
}

//22 strtod
//double strtod(const char *nptr,char **endptr);
/*strtod()会扫描参数nptr字符串，跳过前面的空格字符，
直到遇上数字或正负符号才开始做转换，到出现非数字或
字符串结束时('\0')才结束转换，并将结果返回。
若endptr不为NULL，则会将遇到不合条件而终止的
nptr中的字符指针由endptr传回。
参数nptr字符串可包含正负号、小数点或E(e)来表示指数部分。
如123.456或123e-2。*/
void test_strtod()
{
	char *endptr;
	char a[] = "12345.6789";
	char b[] = "1234.567qwer";
	char c[] = "-232.23e4";
	printf("a=%lf\n", strtod(a, NULL));
	printf("b=%lf\n", strtod(b, &endptr));
	printf("endptr=%s\n", endptr);
	printf("c=%lf\n", strtod(c, NULL));
	printf("b=%lf\n", strtod(b, &endptr));
	printf("endptr=%s\n", endptr);
}

//23 strtok()
//char *strtok(char s[], const char *delim);
/*用来将字符串分割成一个个片段。
参数s指向欲分割的字符串，参数delim则为
分割字符串中包含的所有字符。
当strtok()在参数s的字符串中发现参数delim中包含的分割字符时,
则会将该字符改为\0 字符。在第一次调用时，strtok()必需给予参数s字符串，
往后的调用则将参数s设置成NULL。每次调用成功则返回指向被分割出片段的指针。*/

void test_strtok()
{


	char input[16] = "abc,d,fdf,grt";
	char*p;
	/*strtok places a NULL terminator
	infront of the token,if found*/
	p = strtok(input, ",");
	if (p)
		printf("%s\n", p);
	/*Asecond call to strtok using a NULL
	as the first parameter returns a pointer
	to the character following the token*/
	p = strtok(NULL, ",");
	if (p)
		printf("%s\n", p);
	p = strtok(NULL, ",");
	if (p)
		printf("%s\n", p);
	p = strtok(NULL, ",");
	if (p)
		printf("%s\n", p);
	p = strtok(NULL, ",");
	if (p)
		printf("%s\n", p);
	p = strtok(NULL, ",");
	if (p)
		printf("%s\n", p);
	return 0;
}

//24 strtol 
//long int strtol(const char *nptr, char **endptr, int base);
/*参数base范围从2至36，或0。参数base代表采用的进制方式，
如base值为10则采用10进制，若base值为16则采用16进制等。
当base值为0时则是采用10进制做转换，但遇到如’0x’前置
字符则会使用16进制做转换、遇到’0’前置字符而不是’0x’
的时候会使用8进制做转换。
一开始strtol()会扫描参数nptr字符串，跳过前面的空格字符，
直到遇上数字或正负符号才开始做转换，再遇到非数字或字符
串结束时('\0')结束转换，并将结果返回。若参数endptr不为NULL，
则会将遇到不合条件而终止的nptr中的字符指针由endptr返回；
若参数endptr为NULL，则会不返回非法字符串。
特点编辑
1.不仅可以识别十进制整数，还可以识别其它进制的整数，
取决于base参数，比如strtol("0XDEADbeE~~", NULL, 16)
返回0xdeadbee的值，strtol("0777~~", NULL, 8)返回0777的值。
2.endptr是一个传出参数，函数返回时指向后面未被识别的第一个字符。
例如char *pos; strtol("123abc", &pos, 10);，strtol返回123，
pos指向字符串中的字母a。如果字符串开头没有可识别的整数，
例如char *pos; strtol("ABCabc", &pos, 10);，则strtol返回0，
pos指向字符串开头，可以据此判断这种出错的情况，而这是atoi处理不了的。
3.如果字符串中的整数值超出long int的表示范围（上溢或下溢），
则strtol返回它所能表示的最大（或最小）整数，并设置errno为ERANGE，
例如strtol("0XDEADbeef~~", NULL, 16)返回0x7fffffff并设置errno为ERANGE*/

//25 strupr
//说明：只转换s中出现的小写字母，不改变其它字符。返回指向s的指针
/*void test_strupr()
{
	char p[] = "abcDef,.fas234";
	printf("%s\n", p);
	strupr(p);
	printf("%s\n", p);

	char s[] = "Copywrite 1999-2000 GGV Technologies";
	char* s2 = strupr(s);//把s数组中的字符串转换成大写并且返回s用来初始化s2
	printf("%s", s2);
	printf("%s", s); //这个时候s和s2是相等的，指向同一个字符串。
}*/

//26 swab
//功 能 : 交换相临的两个字节
//用 法 : void swab(char *from, char *to, int nbytes);
/*
void test_swab()
{
	char p1[] = "abcdegf";
	char p2[] = "1232354";
	swab(p1, p2, 4);
}*/