字符串+内存函数（C语言）-创新互联

目录

10年专注成都网站制作，成都企业网站建设，个人网站制作服务，为大家分享网站制作知识、方案，网站设计流程、步骤,成功服务上千家企业。为您提供网站建设,网站制作,网页设计及定制高端网站建设服务,专注于成都企业网站建设,高端网页制作,对成都会所设计等多个领域，拥有多年建站经验。

函数介绍：

字符串函数：

strlen

一道迷惑笔试题：

strcpy

strcat

strcmp

strncpy

strncat

strncmp

strstr

strtok

strerror

字符分类函数：

iscntrl 

isspace

isdigit

isxdigit

islower

isupper

isalpha

isalnum

ispunct

isgraph

isprint

tolower

toupper

内存函数：

memcpy

memmove

memcmp

memset

库函数的模拟实现

模拟实现strlen

模拟实现strcpy

模拟实现strcat

模拟实现strstr

模拟实现strcmp

模拟实现memcpy

模拟实现memmove

---

对C语言中的几个常用的库函数进行解释说明

并彻底了解如何使用

了解原理，并进行模拟实现

strlen

计算字符串长度函数

函数原型：size_t  strlen(const char* str)

返回值：size_t   就是  unsigned int 无符号整型

 返回的是'\0‘之前字符的个数 

参数：const char* str  

 是一个char*的指针 且用const修饰

 const修饰的是*str

表示指针指向的内容是不可被修改的

函数作用：计算的是字符串长度

计算'\0'之前字符的个数

函数的用途：看以下代码：

#include#includeint main()
{
	//创建一个数组 用来封装字符串
	char str[] = "abcdefghjk";
	
	//调用strlen函数,用一个size_t 无符号整型来接收
	//将str数组名表示首元素地址，也就是字符串的首地址传过去
	size_t len = strlen(str);

	//打印，从传过去的位置开始，遇到'\0'之前，字符的个数
	printf("%u\n", len);

	return 0;
}

一道迷惑笔试题：

#include#includeint main()
{
	const char* str1 = "abcdef";
	const char* str2 = "bbb";

	if (strlen(str2) - strlen(str1) >0)
	{
		printf("str2>str1\n");
	}
	else
	{
		printf("srt1>str2\n");
	}

//在判断的时候，strlen(str2)的值为3
//strlen(str1)的值为6
//而 3 和 6 都是size_t类型
//3-6 的实际结果为：-3
// -3 ：
// 原码：10000000 00000000 00000000 00000011
// 反码：11111111 11111111 11111111 11111100
// 补码：11111111 11111111 11111111 11111101
// 
//但因为是无符号整型，将-3的补码实际解读的时候
//是按照无符号数来解读的，因为正数的 原码，反码，补码相同
//所以将-3的补码当做原码解读，是一个很大的数
//该数必定大于0 所以必定指向if里面的语句

	return 0;
}

解析：

答案：str2>str1

在判断的时候，strlen(str2)的值为3
strlen(str1)的值为6
而 3 和 6 都是size_t类型
3-6 的实际结果为：-3
-3 ：
原码：10000000 00000000 00000000 00000011
反码：11111111 11111111 11111111 11111100
补码：11111111 11111111 11111111 11111101

但因为是无符号整型，将-3的补码实际解读的时候
是按照无符号数来解读的，因为正数的 原码，反码，补码相同
所以将-3的补码当做原码解读，是一个很大的数
该数必定大于0 所以必定指向if里面的语句

strcpy

字符串拷贝函数

函数原型：char * strcpy ( char * destination, const char * source );

参数：char * destination, const char * source

将source指向的字符串复制到destination指向的数组中

包括终止字符'\0’也要赋值过去

返回值：char*  

返回的是sourec指向的那一片空间的地址

函数作用：将源头src指向字符串的内容赋值到目的地dest指向字符串中

 在赋值的时候会将字符'\0’也赋值过去

       为避免溢出，destination指向的数组的大小应足够长

以包含与source相同的字符串（包括终止空字符），

并且不应与source在内存中重叠。

函数的使用：看以下代码：

#include#includeint main()
{
	//将str2的内容拷贝到str1中
   //拷贝的时候会将'\0'也拷贝过去
  //str1的空间要足够大要装的下str2的内容！
	char str1[20] = "zzzzzzzzzzzzzz";
	char str2[] = "abcde";
	strcpy(str1, str2);
	printf("%s\n", str1);

	//将s2的内容拷贝到s1中
	//拷贝的时候会将'\0'也拷贝过去
	//s1的空间要足够大要装的大s2的内容
	char s1[] = "xxxxxxxxxx";
	char s2[] = "fghijk";
	strcpy(s1, s2);
	printf("%s\n", s1);

	//将p2指向的常量字符串的内容拷贝到p2中
	//拷贝的时候会将'\0'也拷贝过去
	//p1的空间要足够大要装的大p2的内容
	char p1[20] = "yyyyyyyyyyyyyyyyyy";
	char* p2 = "lmnopq";
	strcpy(p1, p2);
	printf("%s\n", p1);

	return 0;
}

strcat

字符串追加函数

函数原型：char * strcat ( char * destination, const char * source );

返回值：char*

返回的是追加完成之后

destination的首地址

参数：char * destination, const char * source

 destination是目的地字符串的首地址

 source 是源头字符串的首地址

函数作用：

将source指向的字符串内容

追加到destination指向的字符串后面

追加时：destination中的'\0'被source的第一个字符覆盖

destination指向的空间要足够大

要容纳下追加之后的新字符串

函数用途：看以下代码       

#include#includeint main()
{
	//将str2的内容追加到str1的后面
	//在追加的时候str1最后的‘\0’字符被str2的第一个字符覆盖
	//然后进行追加，追加时会将str2的'\0'也追加进去
	//str1的空间要足够大，要能容纳下追加后的新字符串
	char str1[50] = "abcdefg";
	char str2[] = "hijklmn";
	strcat(str1, str2);
	printf("%s\n", str1);

	//将p2指向的常量字符串内容追加到p1的后面
	//追加时p1的'\0'字符被p2的首字符覆盖
	//追加时会将p2的'\0'也追加进去
	//p1的空间要足够大，能容纳下追加后的新字符串
	char p1[20] = "abc";
	char* p2 = "defgk";
	strcat(p1, p2);
	printf("%s\n", p1);

	return 0;
}

 

strcmp

字符串比较函数

函数原型：int strcmp ( const char * str1, const char * str2 );

返回值：int

   返回的是一个有符号整型数

 可返回负数，0，正数

参数：const char * str1, const char * str2

 str1指向一个字符串，

 str1里面存放的是字符串的首地址

 用const修饰说明字符串的内容不可被修改

 str2也指向一个字符串，

 str2里面存放的是字符串的首地址

 用const修饰说明字符串的内容不可被修改

 

函数的作用：

     str1字符串与str2字符串从首字符的位置开始

     一个字符一个字符对应向后一一比较，

     在比较字符的时候比较的是其ASCII码值，

     若对应比较两个字符相等则一直向后比较，

     直到碰到字符不等的情况就停止比较，

     然后返回这两个不等字符的比较结果，

     当str1的字符大于str2的字符 则返回大于0的数字，

     若两个字符串比较完了，各字符都相同，

     且长度相等的情况下，则这两个字符串相等

     str1等于str2时返回0，

     str1的字符小于str2的字符时 返回小于0的数

函数用途：如下代码：

#include#includeint main()
{
	//字符串比较
	//str1 与 str2 进行比较
	//从首字符开始向后一一比较
	//在比较的时候比较的是字符的ASCII码值
	//若对应的字符相等，则继续向后比较
	//若不等，则停止比较，返回他们的比较结果
	//若两个字符串比较完都相等，且长度一样长，说明str2和str2相等
	//返回值：
	//第一个字符串大于第二个字符串，则返回大于0的数字
	//第一个字符串等于第二个字符串，则返回0
	//第一个字符串小于第二个字符串，则返回小于0的数字

	char str1[] = "abcde";
	char str2[] = "abcfk";
	int n = strcmp(str1, str2);
	if (n == 0)
	{
		printf("str1 == str2");
	}
	else if (n >0)
	{
		printf("str1 >str2");
	}
	else
	{
		printf("str1< str2");
	}

	return 0;
}

strncpy

字符串拷贝函数（指定字节数拷贝）

函数原型：char * strncpy ( char * destination, const char * source, size_t num );

返回值：char *

 返回的是一个char* 的指针

 返回的是拷贝完成后的destination指向的空间

参数：char * destination, const char * source, size_t num

 目的地字符串：

 destination 是指向一个字符串空间的指针

 源头字符串：

 soure是一个指向一个字符串空间的指针

 const修饰说明soure指向的字符串不可被修改

 num是一个sizt_t 无符号整型的数字

函数的作用：

     将soure指向的字符串中num个字节的内容

     复制到destination指向的字符串空间

     如果source指向的字符串的长度小于num，

     则拷贝完源字符串之后，在目标的后边追加0，

     直到追加够num个结束

     destination 指向的空间要足够大

     至少能容纳下拷贝后新的字符串

函数用途：如下代码：

#include#includeint main()
{
	//拷贝num个字符从源字符串到目标空间。
	//如果源字符串的长度小于num，则拷贝完源字符串之后，
	//在目标的后边追加0，直到num个

	char str1[] = "yyyyyyyyyyyyyyyyyyy";
	char str2[] = "hello";
	strncpy(str1, str2, 5);
	printf("%s\n", str1);

	//当s2的长度

strncat

字符串追加函数（指定字节数追加）

函数原型：char * strncat ( char * destination, const char * source, size_t num );

返回值：char *

  返回的是一个char*的指针

返回追加完成之后destination指向的空间

参数：char * destination, const char * source, size_t num

 目的地字符串：

 destination 是指向一个字符串空间的指针

 源头字符串：

 soure是一个指向一个字符串空间的指指针

 const修饰 说明soure指向的字符串不可被修改

 num是一个sizt_t 无符号整型的数字

函数的作用：

     将soure指向的字符串中num个字节的内容

  追加到destination指向的字符串空间

     destination指向字符串的最后的'\0'字符

     会被soure指向的字符串的首字符所覆盖

     如果source指向的字符串的长度大于num，

     则追加完num个字符之后，在后边自动加上'\0'

     如果source指向的字符串的长度小于num，

  则只追加完source指向的字符串内容(包含'\0’)

     就结束结束追加

     destination 指向的空间要足够大

     至少能容纳下追加后新的字符串

函数用途：如下代码：

#include#includeint main()
{
	//str2 大于 num 的情况
   //会自动在末尾加上'\0'
	//在追加的时候，str1的'\0'会被str2的首字符所覆盖
	char str1[50] = "uvwxy";
	char str2[] = "abcdefg";
	strncat(str1, str2, 5);
	printf("%s\n", str1);

	//str2 小于 num 的情况
	//只追加完str2包含'\0’字符就结束追加
	//在追加的时候，s1的'\0'会被s2的首字符所覆盖
	char s1[50] = "wasche";
	char s2[] = "hello world";
	strncat(s1, s2, 13);
	printf("%s\n", s1);

	return 0;
}

strncmp

字符串比较函数（指定字节数比较）

函数原型：int strncmp ( const char * str1, const char * str2, size_t num );

返回值：int

   返回的是一个有符号整型数

 可返回负数，0，正数

参数：const char * str1, const char * str2, size_t num

 str1指向一个字符串，

 str1里面存放的是字符串的首地址

 用const修饰说明字符串的内容不可被修改

 str2也指向一个字符串，

 str2里面存放的是字符串的首地址

 用const修饰说明字符串的内容不可被修改

 num是一个无符号整数，表示字节数

函数的作用：

  对str1和str2字符串，指定num个字节进行比较

     str1字符串与str2字符串从首字符的位置开始

  比较到num个字节结束

     一个字符一个字符对应向后一一比较，

     在比较字符的时候比较的是其ASCII码值，

     若对应比较两个字符相等则一直向后比较，

     直到碰到字符不等的情况就停止比较，

     然后返回这两个不等字符的比较结果，

     当str1的字符大于str2的字符 则返回大于0的数字，

     若两个字符串比较num个字节之后，

     各字符都相同，则这两个字符串相等

     str1等于str2时返回0，

     str1的字符小于str2的字符时 返回小于0的数

     若字符串的长度小于num，则比较完字符'\0'就结束比较

函数用途：如下代码：

#include#includeint main()
{
	char str1[] = "abcdefghijklm";
	char str2[] = "abcdefgxyz";
	//比较前六个字符是否相等
	int n = strncmp(str1, str2, 6);
	if (n == 0)
	{
		printf("str1 == str2\n");
	}
	else if (n >0)
	{
		printf("str1 >str2\n");
	}
	else
	{
		printf("str1< str2\n");
	}


	//比较前8个字符是否相等
	n = strncmp(str1, str2, 8);
	if (n == 0)
	{
		printf("str1 == str2\n");
	}
	else if (n >0)
	{
		printf("str1 >str2\n");
	}
	else
	{
		printf("str1< str2\n");
	}

	//比较前11个字符是否相等
	n = strncmp(str1, str2, 11);
	if (n == 0)
	{
		printf("str1 == str2\n");
	}
	else if (n >0)
	{
		printf("str1 >str2\n");
	}
	else
	{
		printf("str1< str2\n");
	}

	return 0;
}

strstr

字符串找子串函数

函数原型：char * strstr ( const char *str1, const char * str2);

返回值：char *

返回一个字符指针

 返回找到子串的首字符的地址

找不到返回NULL

参数：const char *str1, const char * str2

 str1指向一个字符串，

 str1里面存放的是字符串的首地址

 用const修饰说明字符串的内容不可被修改

 str2也指向一个字符串，

 str2里面存放的是字符串的首地址

 用const修饰说明字符串的内容不可被修改

函数的作用：

  寻找在str1指向的常量字符串里

     是否包含str2指向的字符串

     若包含则返回str2第一次出现的地址

     若不包含则返回NULL

函数用途：如下代码：

#include#includeint main()
{
	//查找str2是否是str1的子串
	//若是则返回str2第一次出现的位置
	//若不是则返回NULL
	char str1[] = "abcdefgjklcdefgmn";
	char str2[] = "cdef";
	char* p = strstr(str1, str2);
	if (p == NULL)
	{
		printf("str2 不是 str1 的子串\n");
	}
	else
	{
		printf("str2 是 str1 的子串\n");
		//用%s打印的时候会从str2在str1中第一次出现的位置开始，直到遇到'\0'结束
		printf("%s\n", p);
	}

	return 0;
}

strtok

字符串分割函数

函数原型：char * strtok ( char * str, const char * sep );

返回值：char *

  返回一个字符指针

  返回用分割符号分割后字符串的首地址

参数：char * str, const char * sep

str是一个指向要被分割的字符串的空间

sep指向的是分割符号的字符串空间

用const修饰说明sep指向的内容不可被修改

函数的作用：

sep里面传过来的是分隔符的字符串

在第一次调用的时候

str里面传过来的是要被分割字符串的首地址

在查找分隔符的时候会将分隔符的位置改为'\0'

在第二次调用的时候

str里面传入一个空指针，

此时查找分隔符的位置会在第一次分隔符的下一个字符开始查找

会找到下一个分隔符，再将分隔符的位置改为'\0‘

以此类推有几个分隔符就查找几次

sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，

它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记，

并将其用 \0 结尾，

返回一个指向这个标记的指针。

（注：
    strtok函数会改变被操作的字符串，

           所以在使用strtok函数切分的字符串

        一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，

函数将找到str中第一个标记，

strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为 NULL ，

函数将在同一个字符串中被保存的位置开始，

查找下一个标记。
如果字符串中不存在更多的标记，则返回 NULL 指针

函数用途：如下代码：

#include#includeint main()
{
	char str[] = "hello@world&string#strtok";//被分割的字符串
	char ep[] = "@&#";//分隔符字符串

	//第一次调用 会将找到的分割符的位置改为'\0'
	char* p = strtok(str, ep);
	printf("%s\n", p);

	//第二次调用传入空指针 会将找到的分割符的位置改为'\0'
	p = strtok(NULL, ep);
	printf("%s\n", p);

	//第三次调用也传入空指针 会将找到的分割符的位置改为'\0'
	p = strtok(NULL, ep);
	printf("%s\n", p);

	//第四次调用也传入NULL 会将找到的分割符的位置改为'\0'
	p = strtok(NULL, ep);
	printf("%s\n", p);


	上述我们打印分割的字符串总共调用了四次
	代码写的有点繁琐，我们可以用一个for循环直接调用打印
	//char* ret = NULL;
	//for (ret = strtok(str, ep);ret!=NULL; ret = strtok(NULL, ep))
	//{
	//	printf("%s\n", ret);
	//}

	return 0;
}

strerror

获取错误信息函数

函数原型：char * strerror ( int errnum );

返回值：char *

  返回一个字符指针

  返回的是错误信息是字符串

参数：int errnum

参数是一个整数

传入的是一个错误码

函数的作用：

  返回一个字符串，而这个字符串

  就是一串错误信息

  而参数是一个整数，是一个错误码

  每一个错误码都有一个对应的错误信息

函数用途：如下代码：

#include#include#includeint main()
{
	//随便传入一个错误码，打印出其错误信息
	printf("%s\n", strerror(12));

	//具体应用
	//FILE是一个文件指针，fopen是打开文件
	//在当前目录下打开text.txt文件进行读操作
	//若打开失败返回NULL
	FILE* pf = fopen("text.txt", "r");
	if (pf == NULL)
	{
		printf("打开失败错误信息为：%s",strerror(errno));
	}
	else
	{
		printf("打开成功\n");
	}

	return 0;
}

字符分类函数：

头文件包含：#include

iscntrl 

字符控制函数

函数原型：int iscntrl ( int c );

函数的作用：

  传入一个字符，

判断是否是控制字符

若是则返回非0数(也就是ture)

若不是则返回0(也就是false)

函数用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = iscntrl(c);
	if (ret == 0)
	{
		printf("%c不是控制字符\n", c);
	}
	else
	{
		printf("%c 是控制字符\n", c);
	}

	return 0;
}

isspace

空白字符：‘空格’，‘\f’换页，'\n'换行，

     '\r'回车，制表符‘\t’，垂直制表符'\v'

函数原型：int isspace ( int c );

函数作用：

  传入一个字符，

判断是否是空白字符

若是则返回非0数(也就是ture)

若不是则返回0(也就是false)

函数用途：

#include#includeint main()
{
	//空白字符：‘空格’，‘\f’换页，'\n'换行，'\r'回车，制表符‘\t’，垂直制表符'\v'
	char c = '\n';
	int ret = iscntrl(c);
	if (ret == 0)
	{
		printf("%c不是空白字符\n", c);
	}
	else
	{
		printf("%c 是空白字符\n", c);
	}

	return 0;
}

isdigit

十进制数字0~9

函数原型：int isdigit ( int c );

函数作用：

  传入一个字符，

判断是否是0~9的字符

若是则返回非0数(也就是ture)

若不是则返回0(也就是false)

函数用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isdigit(c);
	if (ret == 0)
	{
		printf("%c不是0~9字符\n", c);
	}
	else
	{
		printf("%c 是0~9字符\n", c);
	}

	return 0;
}

isxdigit

十六进制数字，包括所有十进制数字，小写字母a~f，大写字母A~F

函数原型：int isdigit ( int c );

函数作用：

  传入一个字符，

判断是否是十六进制数

小写字母a~f，大写字母A~F的字符

若是则返回非0数(也就是ture)

若不是则返回0(也就是false)

函数用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isxdigit(c);
	if (ret == 0)
	{
		printf("%c NO is 十六进制\n", c);
	}
	else
	{
		printf("%c YES 十六进制\n", c);
	}

	return 0;
}

islower

小写字母：a~z

函数原型：int islower ( int c );

函数作用：

  传入一个字符，

判断是否是小写字母：a~z

若是则返回非0数(也就是ture)

若不是则返回0(也就是false)

函数用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = islower(c);
	if (ret == 0)
	{
		printf("%c NO is 小写字母\n", c);
	}
	else
	{
		printf("%c YES 小写字母\n", c);
	}

	return 0;
}

isupper

大写字母A~Z

函数原型：int isupper ( int c );

函数作用：

  传入一个字符，

判断是否是大写字母：A~Z

若是则返回非0数(也就是ture)

若不是则返回0(也就是false)

函数用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isupper(c);
	if (ret == 0)
	{
		printf("%c NO is 大写字母\n", c);
	}
	else
	{
		printf("%c YES 大写字母\n", c);
	}

	return 0;
}

isalpha

字母a~z或者A~Z

函数原型：int isalpha ( int c );

函数作用：

  传入一个字符，

判断是否是大写或者小写字母

若是则返回非0数(也就是ture)

若不是则返回0(也就是false)

函数用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isalpha(c);
	if (ret == 0)
	{
		printf("%c NO is 字母\n", c);
	}
	else
	{
		printf("%c YES 字母\n", c);
	}

	return 0;
}

isalnum

字母或者数字，A~Z ，a~z，0~9

函数原型：int isalnum ( int c );

函数作用：

  传入一个字符，

判断是否是

大写或者小写字母或者是数字字符

若是则返回非0数(也就是ture)

若不是则返回0(也就是false)

函数用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isalnum(c);
	if (ret == 0)
	{
		printf("%c NO is 字母或数字\n", c);
	}
	else
	{
		printf("%c YES 字母或数字\n", c);
	}

	return 0;
}

ispunct

标点符号，任何不属于数字或者字母的图形字符(可打印)

函数原型：int ispunct ( int c );

函数作用：

  传入一个字符，

判断是否是

  不属于数字或者字母的图形字符

若是则返回非0数(也就是ture)

若不是则返回0(也就是false)

函数用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = ispunct(c);
	if (ret == 0)
	{
		printf("%c NO is 它属于数字或字母\n", c);
	}
	else
	{
		printf("%c YES  它不属于字母或数字\n", c);
	}

	return 0;
}

isgraph

任何图形字符

函数原型：int isgraph ( int c );

函数作用：

  传入一个字符，

判断是否是图形字符

若是则返回非0数(也就是ture)

若不是则返回0(也就是false)

函数用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isgraph(c);
	if (ret == 0)
	{
		printf("%c NO is 它不是图形字符\n", c);
	}
	else
	{
		printf("%c YES  它是图形字符\n", c);
	}

	return 0;
}

isprint

任何可打印字符，包括图形字符和空白字符

函数原型：int isprint ( int c );

函数作用：

  传入一个字符，

判断是否是可打印的字符

  包含图形字符和空白字符

若是则返回非0数(也就是ture)

若不是则返回0(也就是false)

函数用途：

#include#includeint main()
{
	char c = 0;
	scanf("%c", &c);
	int ret = isprint(c);
	if (ret == 0)
	{
		printf("%c NO is 它不是可打印的字符\n", c);
	}
	else
	{
		printf("%c YES  它是可打印的字符\n", c);
	}

	return 0;
}

tolower

字母大写转小写

函数原型：int tolower ( int c );

函数作用：

  传入一个字符，

判断是否是大写字母A~Z

  若是将其转为对应小写字母

函数用途：

#include#include#includeint main()
{
	//将字符串的大写字母全部转为小写字母
	char str[] = "abcDEfGjK";
	int i = 0;
	for (i = 0; i< strlen(str); i++)
	{
		if (isupper(str[i])!=0)//判断是否是大写字母
		{
			str[i] = tolower(str[i]);//大写转小写
		}
	}
	printf("%s\n", str);

	return 0;
}

toupper

字母小写转大写

函数原型：int toupper ( int c );

函数作用：

  传入一个字符，

判断是否是小写字母a~z

  若是将其转为对应大写字母

函数用途：

#include#include#includeint main()
{
	//将字符串的小写字母全部转为大写字母
	char str[] = "abcDEfGjK";
	int i = 0;
	for (i = 0; i< strlen(str); i++)
	{
		if (islower(str[i])!=0)//判断是否是小写字母
		{
			str[i] = toupper(str[i]);//小写转大写
		}
	}
	printf("%s\n", str);

	return 0;
}