0
点赞
收藏
分享

微信扫一扫

大型ERP设计-业务与功能指引:背靠背销售

钎探穗 06-11 18:00 阅读 1

【 库函数】——字符串函数和内存函数

目录

思维导图:

一:字符串函数

1.1:字符串常规函数

1.1.1:长度不受限制的字符串函数

1.1.1.1:strlen函数

1.1.1.2:strcpy函数

1.1.1.3:strcat函数

1.1.1.4:strcmp函数

1.1.2:长度受限制的字符串函数

1.1.2.2:strncpy函数

1.1.2.3:strncat函数

1.1.2.4:strncmp函数

1.2:字符串非常规函数

1.2.1:strstr 字符串函数

1.2.2:strtok 字符串函数

1.2.3:strerror 字符串函数

二:内存函数

2.1:memcpy内存函数

2.2:memmove内存函数

2.3:memcmp内存函数

2.4:memset内存函数

三:特殊字符函数

3.1:字符分类函数

3.1.1:isspace函数

3.1.2:isdigit函数

3.1.3:islower函数

3.1.4:isupper函数

3.1.5:isalpha函数

3.1.6:isalnum函数

3.2:字符转换函数

3.2.1:tolower函数

3.2.2:toupper函数


思维导图:

一:字符串函数

1.1:字符串常规函数

1.1.1:长度不受限制的字符串函数

1.1.1.1:strlen函数

函数简介:

函数解析: 

函数使用:

#include<stdio.h>
#include<string.h>

int main()
{
	// strlen:求字符串长度
	// size_t strlen(const char* str);
	char arr[] = "abcdefg";
	int len = strlen(arr);
	printf("len = %d\n", len);
    return 0;
}

// 打印结果:len = 7

函数分析:

发现,在 arr字符数组中 arr:[ 'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'g' , '\0' ],注意:'\0' 是此字符串的结束标志,求长度的时候并不将它计算在内,即strlen 函数求的的 '\0' 之前字符的个数。 

模拟实现 strlen 函数:

// 模拟实现 strlen 函数:
int my_strlen(const char* str)
{
	char* s = str;    // 字符指针s 指向数组的第一个字符 'a'
	int count = 0;    // 计数变量 count
	while (*s)        // 判断指针s 指向的是否是 '\0',若是则 *s==0(判断为假,退出循环)
	{
		count++;      // 指针指向的不是 '\0',计数变量加1
		s++;          // 指针指向的不是 '\0',指针s向后移一位
	}
	return count;     // 返回 count 计数变量的值 
}

检查模拟实现的 strlen 函数:

1.1.1.2:strcpy函数

函数简介:

 函数介绍:

通俗的讲:将source字符串拷贝到destination数组空间内。 

实例:

#include<stdio.h>
#include<string.h>

int main()
{
	// strcpy:字符串的拷贝
	// char* strcpy(char* dest,const char* src)
	char arr[] = "abcdefg";
	char arr1[20] = { 0 };
	char* p = strcpy(arr1, arr);
	printf("arr1 = %s\n", arr1);
	printf("p = %s\n", p);
    return 0;
}

打印结果:
// arr1 = abcdefg
// p = abcdefg

 对实例进行分析:其中 arr字符数组(字符串)为源字符串,arr1字符数组是目标空间,strcpy函数的作用就是将arr字符串内容拷贝到 arr1 字符数组中,使得 arr1字符数组空间内含 "abcdefg"。注意:arr1 的数组空间必须要大于被拷贝的内容。

函数没有运行前:各个数组在内存中的信息

 函数运行后:各个数组在内存中的信息

模拟实现 strcpy 字符串函数:

实现:

// 模拟实现 strcpy 函数
char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);            // 此处为断言,判断源字符空间和目标空间是否为空,为空则报错,这里不做讲解。
	char* ret = dest;               // 先将目标空间的起始地址保存下来

	while (*src)                    // 判断 src指针是否走到 '\0' 的位置,是则退出循环
	{
		*dest = *src;               // 将 src 指针指向的字符赋给 dest 指针指向的位置
        ++dest;                     // dest指针+1      
        ++src;                      // src指针+1
	}
    *dest = *src;                    // 将 '\0' 赋给 dest指针 指向的空间

	return ret;                      // 返回ret(目标空间的起始地址)
}

 查看模拟情况:

模拟成功! 

1.1.1.3:strcat函数

函数简介:

函数介绍:

 函数使用实例:

#include<stdio.h>
#include<string.h>

int main()
{
    // strcat 字符串连接函数
    // char* strcat(char* destination, const char* source)
    char arr[30] = "hello ";
    char arr1[] = "china";
    char* p = strcat(arr,arr1);
    printf("p = %s\n",p);
    printf("arr = %s\n",arr);
    return 0;
}

// 打印结果:
// p = hello china
// arr = hello china

分析:

函数运行前字符数组在内存中的情况:

函数运行后字符数组在内存中的情况: 

 发现,在函数运行之后在 arr字符串之后添加了arr1字符串的内容,并且 arr1 中的内容没有变化。

模拟实现 strcat 字符串连接函数:

 实现:

// 模拟实现 strcat 函数
char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);                // 断言
	char* ret = dest;                   // 存目标空间的首地址

	while (*dest)                       // 检查 dest 指针指向的字符是否是 '\0',是则退出循环
	{
		dest++;        
	}
	while (*src)                        // 检查 src 指针是否拷贝到 '\0' 这个位置。是就结束
    {
        *dest = *src;
        ++dest;
        ++src;
    }
    *dest = *src;                        // 将源字符串的最后一个字符'\0'拷贝到目标空间中
	return ret;                          // 返回目标空间的首地址
}

检查自我模拟的字符串连接函数:

运行前字符数组内存情况:

 运行后字符数组内存情况:

模拟成功!

1.1.1.4:strcmp函数

函数简介:

函数介绍:

函数实例:

#include<stdio.h>
#include<string.h>

int main()
{
	// strcmp:字符串的比较
	char a[] = "abcd";
	char b[] = "abcdef";
	int x = strcmp(a, b);
    // 比较各个相应字符的ASCII码值
	// a > b  -->  1
	// a = 0  -->  0
	// a < b  -->  -1
	printf("x = %d\n", x);
    return 0;
}

// 打印结果:
// x = -1

分析:a字符串中内容 "abcd",b字符串中内容 "abcdef"。先开始比较每个字符串的第一个字符,因为它们第一个字符都是 'a',相等。在继续执行两个字符串的第二个字符,相等则继续执行,当执行到第五个字符时,a[4] = '\0',b[4] = 'e',字符e的ACSII码值大于'\0'的ACSII码值,所以b字符串大于 a 字符串。返回一个小于0的数,一般就是 -1。

模拟strcmp字符串比较函数:

// 模拟实现 strcmp 函数
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);            // 断言(检查是否有错误)

	while (*str1 == *str2)           // 检查对应字符是否相等
	{
		++str1;                      // 相应字符相等,指针+1,往后移一位
		++str2;
		if (*str1 == '\0')           // 如果一个字符串遇到'\0'结束了 ,就退出循环	
        {
			break;
		}
	}

	if (*str1 > *str2)            // 判断对应的两个字符谁大谁小
	{
		return 1;                    // 第一个字符大就返回1
	}
	else if (*str1 < *str2)
	{
		return -1;                // 第二个字符大就返回-1
	}
	else
		return 0;                 // 两个字符相等就返回0
}

检查模拟的函数是否正确:

模拟函数成功!

1.1.2:长度受限制的字符串函数

所谓长度受限制,就是当使用字符串函数操作字符串时,并不仅仅直接操作整个字符串,而是操作字符串中的 n 个字符。

1.1.2.2:strncpy函数

函数简介:

函数介绍:

函数使用实例:

#include<stdio.h>
#include<string.h>

int main()
{
	// strncpy:长度受限制的字符串拷贝
	// char* strncpy(char* dest,const char* src,size_t num)
	char arr[] = "abcdef";
	char arr1[30] = { 0 };
	char* p = strncpy(arr1, arr, 2);
	printf("p = %s\n", p);
	printf("arr1 = %s\n", arr1);
    return 0;
}

// 打印结果:
// p = ab
// arr1 = ab

 分析:长度受限制的字符串拷贝,即将 arr 字符串中从前往后取出 2 个字符 "ab",拷贝到 arr1 字符数组空间内。并返回目标空间的起始地址。

模拟实现 strncpy 字符串拷贝函数:

// strncpy 函数模拟实现
char* my_strncpy(char* dest, const char* src, size_t num)
{
	assert(dest && src);                // 断言(检查错误)
	char* ret = dest;                   // 记录下目标空间的起始地址

	while (num)                         // 循环 num 次,即拷贝字符 num 个
	{
		*dest = *src;                   // 源字符串 src指针指向的字符赋给目标空间
		if (*dest == '\0')              // 检测 src赋给dest的字符是否是'\0',是则退出循环
		{
			break;
		}

		++dest;                          // 赋完值后 dest+1,往后移一步
		++src;
		--num;                           // 赋完一次值,num值减一
	}
	while (num)                          // src字符串已全部拷贝到目标空间后,num仍是大于0
	{
		*dest = '\0';                    // dest指针指向的字符之后的内容全部赋值为 '\0'
		++dest;
        --num;                        // 直至num值变为0
	}
	return ret;
}

检查模拟函数是否正确:

模拟成功! 

1.1.2.3:strncat函数

函数简介:

函数介绍:

函数应用实例:

#include<stdio.h>
#include<string.h>

int main()
{
	// strncat:长度受限制的字符串连接
	// char* strncat(char* dest,const char* src,size_t num)
	char arr[20] = "hello ";
	char arr1[] = "china";
	char* p = strncat(arr, arr1, 2);
	printf("p = %s\n", p);
	printf("arr = %s\n", arr);
    return 0;
}

// 打印结果:
// p = hello ch
// arr = hello ch

分析:长度受限制的字符串连接函数,arr 字符串 "hello ",arr1 字符串 "china"。从 arr1 字符串从前往后取2个字符("ch"),连接到目标空间arr字符串的后面。

注意:目标空间内必须保证有足够的空间来存放所被连接的字符串。

模拟实现 strncat 字符串连接函数:

// 模拟实现 strncat 函数
char* my_strncat(char* dest, const char* src, size_t num)
{
	assert(dest && src);            // 断言(检查是否报错)
	char* ret = dest;               // 将目标空间的起始地址保存
	char* s = src;                  // 通过一个指针来代替src移动
	while (*dest)                   // 找到目标空间的'\0'的位置
	{
		dest++;
	}                                
    // 此时 dest指针指向的内容是'\0'
	while (num)                     // 循环连接 num 次
	{
		*dest = *s;                 // 将指针s的指向的内容赋值给 dest的位置
		if (*s == '\0')             // 检查指针s的指向内容是否为'\0'(结束)
		{
			break;
		}
		++dest;                    // 赋值完之后,dest往后移一位
		++s;                       // 赋值完之后,s往后移一位
		--num;                     // num减一,
	}
	if (num == 0)                   // 当连接 num 个字符后,指针dest指向的位置空间赋值'\0'
	{
		*dest = '\0';
	}
	while (num)                    // 源字符串结束之后,num 值仍大于0,将dest指向位置之后的   num个位置内容都赋值为 '\0'
	{
		*dest = '\0';
		++dest;
	}

	return ret;

}

检查模拟函数是否正确:

 模拟成功!

1.1.2.4:strncmp函数

函数简介:

函数介绍:

 函数使用实例:

#include<stdio.h>
#include<string.h>

int main()
{
	// strncmp:长度受限制的字符串比较
	// int strncmp(arr1,arr2,n)
	char a[] = "abcd";
	char b[] = "abcdef";
	int x = strncmp(a, b, 4);
	// a > b  -->  1
	// a = 0  -->  0
	// a < b  -->  -1
	printf("x = %d\n", x);

    return 0;
}

// 打印结果:
// x = 0

分析:a字符数组中取出4个字符为 "abcd",b字符数组中取出4个字符为 "abcd"。"abcd"与"abcd"依次比较对应相等,返回0。

模拟实现 strncmp 字符串比较函数:

// 模拟实现 strncmp 函数
int my_strncmp(const char* str1, const char* str2, size_t num)
{
	assert(str1 && str2);

	while (*str1 == *str2 && num)        // 判断str1和str2指向的内容是否相等,判断num值是否减到0
	{
		++str1;
		++str2;
		--num;
	}
	if (*str1 > *str2)
	{
		return 1;
	}
	else if (*str1 < *str2)
	{
		return -1;
	}
	else
	{
		return 0;
	}

}

检测模拟的函数是否正确:

 模拟成功!

1.2:字符串非常规函数

所谓非常规函数,就是我们在学习的过程中并不需要深度了解它们,只需要学会使用即可,在我们做题时使用该系列函数可以快速地解决问题。

1.2.1:strstr 字符串函数

函数简介:

 函数介绍:

看例题:

#include<stdio.h>
#include<string.h>

int main()
{
	// strstr:字符串中找一个字符串
	// char* strstr(const char* str1,const char* str2)
	// 在 str1 中找 str2,返回 str2 在 str1 中第一次出现的位置	找不到就返回 NULL
	char arr[] = "abcdefabcdef";
	char arr1[] = "def";
	char* ret = strstr(arr, arr1);
	printf("ret = %s\n", ret);
    return 0;

}


// 打印结果:
// ret = defabcdef

分析:arr字符串"abcdefabcdef" ,arr1字符串"def"。在arr字符串内找arr1,即arr字符数组第3个位置可找到,返回一个指向字符 'd' 的地址。

 提交答案:

#include<stdio.h>
#include<string.h>

int main()
{
    char arr[20] = { 0 };
	char arr1[20] = { 0 };

	gets(arr);
	gets(arr1);

	// 在arr中找arr1
	char* ret1 = strstr(arr, arr1);
	char* ret2 = strstr(arr1, arr);
	if (ret1!=NULL)
	{
		printf("%s is substring of %s\n", arr1, arr);
	}
	else if(ret2!=NULL)
	{
		printf("%s is substring of %s\n", arr, arr1);
	}
	else
	{
		printf("No substring\n");
	}
	return 0;
}

1.2.2:strtok 字符串函数

函数简介:

 函数介绍:

 函数使用样例:

#include<stdio.h>
#include<string.h>

int main()
{
	// strtok:用作分隔符的字符串
	// char * strtok ( char * str, const char * delimiters );
	char arr[] = "china!victory@year.net";
	char cpy[30] = { 0 };
	strcpy(cpy, arr);
	char set[] = "@,.,!";        // 此处的分隔符无顺序讲究
	char* ret = NULL;
	for (ret = strtok(cpy, set); ret != NULL; ret = strtok(NULL, set))
	{
		printf("%s\n", ret);
	}
    return 0;
}


// 打印结果:
// china
// victory
// year
// net

1.2.3:strerror 字符串函数

函数简介:

函数介绍:

 看实例:

#include<stdio.h>
#include<string.h>

int main()
{
	// strerror:错误码所对应的错误信息
	// char* strerror(int errnum)
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d:%s\n", i, strerror(i));
	}
    return 0;
}

// 打印结果:
// 0:No error
// 1:Operation not permitted
// 2:No such file or directory
// 3:No such process
// 4:Interrupted function call
// 5:Input/output error
// 6:No such device or address
// 7:Arg list too long
// 8:Exec format error
// 9:Bad file descriptor

那么,为什么会有这样的错误码和错误原因呢?这是因为C语言中库函数在执行的过程中,发生了错位,会将一个错误码存放在errno(C语言提供的一个全局变量)这个变量中。

二:内存函数

所谓内存函数,即在内存上存储的数据都可以进行相应的操作,不单单是针对于字符,还可以对整形,浮点型,结构体等等进行操作。

2.1:memcpy内存函数

函数简介:

void* memcpy(void* destination, const void* source, size_t num);

使用示例:

#include<stdio.h>
#include<string.h>

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	memcpy(arr2, arr1, 40);
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		printf("%d ", arr2[i]);
	}
    return 0;
}


// 打印结果:
// 1 2 3 4 5 6 7 8 9 10 0 0 0 0 0 0 0 0 0 0

函数运行前数组arr2数据在内存中情况:

函数运行后数组arr2数据在内存中情况:

分析:因为 num 值针对的是字节,而一个整形占4个字节,所以40个字节就是占的10个数字。所以其拷贝的就是arr1的前10个数字。

再看一例题:

#include<stdio.h>
#include<string.h>

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	memcpy(arr2, arr1, 24);
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		printf("%d ", arr2[i]);
	}
    return 0;
}


// 打印结果:
// 1 2 3 4 5 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0

 模拟实现 memcpy 内存拷贝函数:

// 模拟 memcpy内存函数
// void* memcpy(void* destination, const void* source, size_t num);

void* my_memcpy(void* dest, const void* src, size_t num)
{
	assert(dest && src);

	while (num)                        // 循环 num 次(num个字节)
	{
		*(char*)dest = *(char*)src;    // 在未知是什么类型的情况下,要将其类型转成char*类型
		dest = (char*)dest + 1;
		src = (char*)src + 1;
		--num;
	}

}

检测模拟的函数是否正确:

模拟成功! 

2.2:memmove内存函数

函数简介:

void * memmove ( void * destination, const void * source, size_t num );

使用示例:

#include<stdio.h>
#include<string.h>

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1 + 3, arr1, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
    return 0;
}


// 打印结果:
// 1 2 3 1 2 3 4 5 9 10

函数运行前数组arr1数据在内存中情况:

函数运行后数组arr1数据在内存中情况:

分析:

" memmove(arr1 + 3, arr1, 20) "的含义是:在 arr1 数组内取20个字节,因为其类型是整形,所以取出5个整数,将这5个整数放到 arr1+3 这个位置上,将原来的5个数据覆盖掉。

 模拟实现 memmove 内存移动函数:

// 模拟 memmove 内存移动函数
// void * memmove ( void * destination, const void * source, size_t num )
void* my_memmove(void* dest, const void* src, size_t num)
{
	assert(dest && src);

	if (src > dest)
	{

		while (num)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;

			--num;
		}

	}
	else
	{

		while (num)
		{
			*((char*)dest + num-1) = *((char*)src + num-1);
			--num;
		}
	}
}

 检测模拟的函数是否正确:

模拟成功! 

2.3:memcmp内存函数

函数简介:

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

使用示例: 

#include<stdio.h>
#include<string.h>

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,2,234,45 };
	int ret = memcmp(arr1, arr2, 9);
	printf("ret = %d\n", ret);
    return 0;
}


// 打印结果:
// x = -1

 注意:这里的 memcmp 比较的并不是依次比较的数字,而是各个字节(9个字节)。因为此函数通常使用率不高,此处不再进行讲解。

2.4:memset内存函数

函数简介:

void * memset ( void * ptr, int value, size_t num );

 使用示例:

#include<stdio.h>
#include<string.h>

int main()
{
	char arr[20] = { 0 };
	memset(arr, 'a', 10);
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		printf("%c ", arr[i]);
	}
    return 0;
}


// 打印结果:
// a a a a a a a a a a

函数运行前数组arr数据在内存中情况:

函数运行后数组arr数据在内存中情况:

注意: 此函数一般适用于字符数组

 这里此函数大家可不必深入理解,会用就OK,此处也不再进行讲解。

三:特殊字符函数

不要求深度理解,记得它们会用就OK!

注意:它们所使用的库函数是 <ctype.h>

3.1:字符分类函数

函数

如果他的参数符合下列条件就返回真

isspace

空白字符:空格 ‘ ’ ,换页 ‘\f’ ,换行 '\n' ,回车 ‘\r’ ,制表符 '\t' 或者垂直制表符 '\v'

isdigit

十进制数字 0~9

islower

小写字母 a~z

isupper

大写字母A~Z

isalpha

字母a~z或A~Z

isalnum

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

3.1.1:isspace函数

该函数大部分都是用来检查字符串中是否含有空格。只要有空格就返回真!

使用实例:

#include<stdio.h>
#include<ctype.h>

int main()
{
	char arr[] = "sdsdf123 2fsdvf3 43 sdf";
	int space_count = 0;
	int len = strlen(arr);
	for (int i = 0; i < len; i++)           // 遍历arr字符数组内的各个字符
	{
		if (isspace(arr[i]))                // 遇到空格,计数空格变量就加1
		{
			space_count++;                   
		}
	}
	printf("space_count = %d\n", space_count);

}

// 打印结果:
// 3

3.1.2:isdigit函数

使用该函数,只要遇到十进制数字 0~9就返回真。

使用示例:

#include<stdio.h>
#include<ctype.h>

int main()
{
	char arr[] = "sdsdf123 2fsdvf3 43 sdf";
	int digit_count = 0;
	int len = strlen(arr);
	for (int i = 0; i < len; i++)         // 遍历arr字符数组内的各个字符
	{
		if (isdigit(arr[i]))              // 遇到十进制数字0-9,计数变量就加1
		{
			digit_count++;
		}
	}
	printf("digit_count = %d\n", digit_count);

}


// 运行结果:
// digit_count = 7

3.1.3:islower函数

使用该函数,只要遇到小写字母a~z就返回真。

使用示例:

#include<stdio.h>
#include<ctype.h>

int main()
{
	char arr[] = "sSFdsdSFDf123 2fsdFDvf3 43SF sdf";
	int lower_count = 0;
	int len = strlen(arr);
	for (int i = 0; i < len; i++)         // 遍历arr字符数组内的各个字符
	{
		if (islower(arr[i]))              // 遇到小写字母a~z,计数变量就加1
		{
			lower_count++;
		}
	}
	printf("lower_count = %d\n", lower_count);
    return 0;
}


// 打印结果:
// lower_count = 13

3.1.4:isupper函数

使用该函数,只要遇到大写字母A~Z就返回真。

使用示例:

#include<stdio.h>
#include<ctype.h>

int main()
{
	char arr[] = "sSFdsdSFDf123 2fsdFDvf3 43SF sdf";
	int upper_count = 0;
	int len = strlen(arr);
	for (int i = 0; i < len; i++)         // 遍历arr字符数组内的各个字符
	{
		if (isupper(arr[i]))              // 遇到大写字母A~Z,计数变量就加1
		{
			upper_count++;
		}
	}
	printf("upper_count = %d\n", upper_count);
    return 0;
}


// 打印结果:
// upper_count = 9

3.1.5:isalpha函数

使用该函数,只要遇到字母a~z或A~Z就返回真。

使用示例:

#include<stdio.h>
#include<ctype.h>

int main()
{
	char arr[] = "sSFdsdSFDf123 2fsdFDvf3 43SF sdf";
	int alpha_count = 0;
	int len = strlen(arr);
	for (int i = 0; i < len; i++)         // 遍历arr字符数组内的各个字符
	{
		if (isalpha(arr[i]))              // 遇到字母a~z或A~Z,计数变量就加1
		{
			alpha_count++;
		}
	}
	printf("alpha_count = %d\n", alpha_count);
    return 0;
}


//  打印结果:
// alpha_count = 22

3.1.6:isalnum函数

使用该函数,只要遇到字母或者数字,a~z,A~Z,0~9就返回真。

使用示例:

#include<stdio.h>
#include<ctype.h>

int main()
{
	char arr[] = "sSFdsdSFDf123 2fsdFDvf3 43SF sdf";
	int alnum_count = 0;
	int len = strlen(arr);
	for (int i = 0; i < len; i++)         // 遍历arr字符数组内的各个字符
	{
		if (isalnum(arr[i]))              // 只要遇到字母或者数字,a~z,A~Z,0~9,计数变量就加1
		{
			alnum_count++;
		}
	}
	printf("alnum_count = %d\n", alnum_count);
}


//  打印结果:
// alnum_count = 29

3.2:字符转换函数

3.2.1:tolower函数

功能:将大写字母转变成小写字母。

函数简介:

int tolower ( int c );

为什么传递的是整形?因为字符在内存中存放的是其ASCII码值,即字符也是属于整形的一类。 

使用实例:

#include<stdio.h>
#include<ctype.h>

int main()
{

	// toupper(小写字母-->大写字母)
	// int toupper(int c)

	char arr[] = "AFADFSADFD";
	int len = strlen(arr);
	for (int i = 0; i < len; i++)        // 遍历arr字符数组内的各个字符
	{
		if (isupper(arr[i]))             // 如果有字符是大写字母,就将其转换成小写字母
		{
			arr[i] = tolower(arr[i]);
		}
	}
	printf("%s\n", arr);

}

// 打印结果:
// afadfsadfd



注意:该函数所包含的头文件是 <ctype.h>

3.2.2:toupper函数

功能:将小写字母转变成大写字母。

函数简介:

int toupper ( int c );

使用示例:

#include<stdio.h>
#include<ctype.h>

int main()
{
	// tolower(大写字母-->小写字母)
	// int tolower(int c)            

	char arr[] = "afadfsadfd";
	int len = strlen(arr);
	for (int i = 0; i < len; i++)        // 遍历arr字符数组内的各个字符
	{
		if (islower(arr[i]))             // 如果有字符是小写字母,就将其转换成大写字母
		{
			arr[i] = toupper(arr[i]);
		}
	}
	printf("%s\n", arr);

}

// 打印结果:
// AFADFSADFD
举报

相关推荐

0 条评论