无字符串长度限制的字符串函数

1. strlen 计算字符串长度

strlen 函数的参数

size_t strlen ( const char * str );
1

• strlne 是计算字符 ‘\0’ 之前所有字符的的个数，不包括 \0
• strlen 的函数返回值是 unsigned int 类型，无符号整形
• strlen 的参数指向的字符串的结尾必须包涵 \0，字符串是以 \0作为结束标志

strlen 的使用方法

#include<string.h>
int main()
{
	char arr[] = { "abcde" };
	int n = strlen(arr);
	int i = 0;
	for (i = 0; i < n; i++)
	{
		printf("%c ", arr[i]);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

关于 strlen 函数的返回值是size_t,也就是uisigned int 的例题

int main()
{
	const char* n = "abcdef";
	const char* x = "abx";
	if (strlen(x) - strlen(n) > 0)
	{
		printf("x > n\n");
	}
	else
	{
		printf("n > x\n");
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 题解

上面的例题中，n的字符串个数是 6，x 的字符串个数是 3
3 - 6 = -3
正常的结果是 n > x
但是之前说过 strlen函数的返回的是 size_t，是无符号的
-3 如果被当成无符号数来解读的话，那就没有符号位的概念了
-3 就会被解读成一个超级大的正数，就会大于 0
结果： x > n

2. strcpy 字符串拷贝

strcpy 函数的参数

char* strcpy(char * destination, const char * source );
1

• strcpy 字符串拷贝的源字符串必须以 \0 为结束标志
• strcpy 会将源字符串中的 ‘\0’ 拷贝到目标空间中
• 拷贝的目标空间必须足够大，拷贝后能够存放字符串
• strcpy 拷贝的字符串必须是可改变的，不能是常量字符串

strcpy 函数的使用
strcpy 里的第一个参数是拷贝的目标空间，第二个参数是拷贝的内容

int main()
{
	char arr[20] = { "################" };
	char x[] = { "hello china" };
	strcpy(arr, x);
	printf("%s", arr);

	return 0;
}
1
2
3
4
5
6
7
8
9

3. strcat 字符串追加

strcat 函数的参数

char * strcat ( char * destination, const char * source );
1

strcat 字符串追加，是在字符串 A 后面在追加一个字符串 B

• strcat 的源字符串必须以 \0 为结束标志
• strcat 的被追加的空间必须能够存放的下追加的字符串
• strcat 的源字符串必须是可改变的，不能是常量字符串

strcat 函数的使用

int main()
{
	char arr[20] = { "hello " };
	char arr2[] = "china";
	strcat(arr, arr2);
	printf("%s\n", arr);

	return 0;
}
1
2
3
4
5
6
7
8
9

• strcat 函数追加会把 arr2 的所有字符串拷贝到arr1里，包括\0

• arr2拷贝时会把arr1 里的\0 覆盖，所以 strcat 函数不能 字符串A 追加 字符串A
  

4. strcmp 字符串比较

strcmp 函数的参数

int strcmp ( const char * str1, const char * str2 );
1

• strcmp函数的判断标准规定：
  第一个字符串大于第二个字符串，则返回大于0的数字
  第一个字符串等于第二个字符串，则返回0
  第一个字符串小于第二个字符串，则返回小于0的数字

• strcmp 是比较每个字符串的第一个字符， 如果相等，
  则继续比较下一对字符，直到字符不相等或到达终止空字符

strcmp 函数使用

int main()
{
	char arr[] = { "abcdefg" };
	char str[] = { "abg" };
	int ret = strcmp(arr, str);
	if (ret > 0)
	    printf("arr > str");
	else if (ret < 0)
		printf("arr < str");
	else
		printf("arr == str");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

有字符串长度限制的字符串函数

1. strncpy 字符串拷贝

strncpy 函数的参数

char * strncpy ( char * destination, const char * source, size_t num );
1

• strncpy 和 strcpy 函数的使用方法都差不多，只是多了一个参数 size_t num
• 多出来的参数是来限制字符串拷贝的长度，增加了安全性
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加\0，直到num个

strncpy 函数的使用

int main()
{
	char arr[25] = { "hello worle!" };
	char arr2[] = { "For a better tomorrow!########" };
	strncpy(arr, arr2, 22);
	printf("%s\n", arr);
	return 0;
}
1
2
3
4
5
6
7
8

2. strncat 字符串追加

strncat 函数参数

char * strncat ( char * destination, const char * source, size_t num );
1

• 和 strcat 函数使用的方法和规则都差不多，只是多了一个参数 size_t num
• num 这个参数代表需要追加几个字符串

strncat 函数使用

int main()
{
	char arr[20] = "hello ";
	char* str = "world! For a better tomorrow!";
	strncat(arr, str, 6);
	printf("%s\n", arr);

	return 0;
}
1
2
3
4
5
6
7
8
9

3. strncmp 字符串比较

strncmp 函数参数

int strncmp ( const char * str1, const char * str2, size_t num );
1

• 规则和 strcmp 同上
• 多出来的一个参数是用来要比较字符串的个数

strncmp 函数使用
比较3个字符串的大小

int main()
{
	char arr[] = { "abgefg" };
	char str[] = { "abgaaaa" };
	int ret = strncmp(arr, str,3);
	if (ret > 0)
	    printf("arr > str");
	else if (ret < 0)
		printf("arr < str");
	else
		printf("arr == str");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4. strstr 在字符串中查找另一字符串

strstr 函数参数

char * strstr ( const char *str1, const char * str2);
1

• 作用：在A 字符串中查找是否包含 B字符串
  如果 A 中包含 B ，则返回 B 在 A 中首次出现的的地址。
  否则返回空指针！
• 如果找到，返回的是字符串的地址，所以要用指针变量来接收

strstr 函数使用

int main()
{
	char arr[] = { "abcdefg" };
	char str[] = { "cde" };
	char* ret = strstr(arr, str);
	if (ret == NULL)
		printf("没有找到\n");
	else
		printf("%s\n", ret);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

5. strtok 切割字符串

strtok 函数参数

char * strtok ( char * str, const char * sep );
1

• 第一个参数是一个字符串，它包含了0个或者多个字符

• 第二个参数是分割字符串，对第一个参数的字符串扫描，碰到了分割字符串中的任意一个
  就把那个字符标记成 ‘\0’ ，然后返回分割字符串之前的地址，并且保存它在字符串中的位置

• strtok函数第二次查找的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记
  如果字符串中不存在更多的分割字符，则返回 NULL 指针。

• strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改

strtok 函数使用
这种方法比较麻烦，而且代码重复度高

int main()
{
	char* arr = { "zhangsan@china.guandong" };
	const char* n = "@.";
	char str[30];
	strcpy(str, arr);
	char* tmp = NULL;

	tmp = strtok(str, n);
	printf("%s\n", tmp);

	tmp = strtok(NULL, n);
	printf("%s\n", tmp);

	tmp = strtok(NULL, n);
	printf("%s\n", tmp);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

简化版
可以用 for 循环巧妙的达成了，结果都是一样的

int main()
{
	char* arr = { "zhangsan@china.guandong" };
	const char* n = "@.";
	char str[30];
	char* tmp = NULL;
	strcpy(str,arr);
	for (tmp = strtok(str, n); tmp != NULL; tmp = strtok(NULL,n))
	{
		printf("%s\n", tmp);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

6. strerror 解析错误码

strerror 函数参数

char * strerror ( int errnum );
1

• 在使用库函数的时候，调用库函数失败时，都会设置错误码
• C语言中有一个全局变量叫 errno，只要调用库函数发生错误，就会把错误码放到errno里
• strerror 会把错误码翻译成对应的错误信息
• 使用必须包涵头文件 <errno.h>

srerror的使用
返回的都是对应的错误信息

int main()
{
	printf("%s\n", strerror(0));
	printf("%s\n", strerror(1));
	printf("%s\n", strerror(2));
	printf("%s\n", strerror(3));
	printf("%s\n", strerror(4));
	printf("%s\n", strerror(5));

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

具体用法：
正常是 strerror 里放 errno，errno 里存放的是错误码

int main()
{
	FILE* pFile;
	pFile = fopen("test.txt", "r");//打开test.txt,以读的形式打开文件
	if (pFile == NULL) // 打开失败就是空指针
		printf("%s\n", strerror(errno));
		//错误码自动保存在 errno 变量当中
	return 0;
}
1
2
3
4
5
6
7
8
9

perror 解析错误码，打印信息

perror 函数参数

void perror(const char* str);
1

• perror 的头文件是 <stdio.h>
• perror 和 strerror 作用都是一样的，不过strerror 没有打印
• perror 是把错误码转换成错误信息，在打印

int main()
{
	//1. 打开文件失败时，返回NULL
	FILE* pd = fopen("test.txt", "r"); 
	if (pd == NULL)
	{
		perror("错误信息");
		return 1;
	}

	// 2. 读文件
	// .....
	//3. 关闭文件
	fclose(pd);
	pd = NULL;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

字符操作函数

• 以上函数的头文件：<ctype.h>

函数使用示范：

1. isdigit 判断是否是数字字符

int main()
{
	char ch = '#';
	int ret = isdigit(ch);
	printf("%d\n", ret);
	return 0;
}
1
2
3
4
5
6
7

• 下面例题可以得知，如果是数字字符，返回的是非0的数字
• 不是数字字符，返回数字 0

#include<ctype.h>

int main()
{
	char ch = '3';
	int ret = isdigit(ch);
	printf("%d\n", ret);
	return 0;
}
1
2
3
4
5
6
7
8
9

答案：

2. islower 判断是否是小写字符

• islower 判断是小写字符返回的是 非0 ，不是返回 0

#include<ctype.h>
int main()
{
   char ch = 'a';
   int ret = islower(ch);
   printf("%d\n",ret);
   return 0;
}
1
2
3
4
5
6
7
8

答案：

• 以上只是简略的写几个例子，剩下的用法都是大同小异

字符转换函

tolower 字符转小写

#include<ctype.h>
int main()
{
	char arr[20] = { 0 };
	scanf("%s", &arr);
	int i = 0;
	while (arr[i] != '\0')
	{
		if (isupper(arr[i])) //判断是否是大写字母
		{
			arr[i] = tolower(arr[i]);
		}
		printf("%c ", arr[i]);
		i++;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

toupper 字符转大写

int main()
{
	char arr[20] = { 0 };
	scanf("%s", &arr);
	int i = 0;
	while (arr[i] != '\0')
	{
		if (islower(arr[i])) //判断是否是小写字母
		{
			arr[i] = toupper(arr[i]); //转换成大写字符
		}
		printf("%c ", arr[i]);
		i++;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16