字符函数和字符串函数2（C语言进阶）

三.长度受限制的字符串函数介绍

1.strncpy

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

说明：
1、当src字符串长度小于n时，则拷贝完字符串后，剩余部分将用空字节填充，直到n个
strncpy不会向dest追加’\0’。
2、src和dest所指的内存区域不能重叠，且dest必须有足够的空间放置n个字符

与strcpy的区别
1、strcpy() 函数用来复制字符串；strncpy()用来复制字符串的前n个字符，所以要多传一个参数n
大家可以对比一下两个函数原型：

char *strcpy(char *dest, const char *src);
1

char * strncpy(char *dest, const char *src, size_t n);
1

2、不像strcpy()，strncpy()不会向dest追加结束标记’\0’
模拟实现：

//模拟实现strncpy
#include
#include
#include
char* my_strncpy(char* dest, const char* src, int num)
{
	char* ret = dest;
    assert(dest && src);
	while (num && (*dest++ = *src++))
	{
		num--;
	}
	if (num)
	{
		while (num--)
		{
			*dest++ = '\0';
		}
	}
	return ret;
}
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "xxxxxxxx";
	my_strncpy(arr1, arr2, 5);
	printf("%s\n", arr1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

运行结果：

2.strncat

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

说 明：
1.dest要有足够的空间来容纳要拷贝的字符串
2.strncat会将dest字符串最后的’\0’覆盖掉，字符追加完成后，再追加’\0’
3.如果num大于字符串src的长度，那么仅将src全部追加到dest的尾部；如果num小于字符串src的长度，该字符会将src的所有字符附加在dest末尾。无论哪种情况，都会在新字符串的末尾添加空字符。
与strcat的区别
大家可以先对比一下两个函数：

char* My_strcat(char* dest, const char* src)
1

char* My_strncat(char* dest, const char* src, int n)

1
2

1、strcat()增加字符串的结束条件是src == ‘\0’；

 strncat的循环结束的条件则是所要追加的字符串个数为0；
1

2、strcat() 函数把源字符串整个连接到目标字符串的后面；

  strcat()方便之处在于只用传两个参数可以实现，比较简便；

  strncat()用来连接源字符串的前n个字符到目标字符串后，所以要多传一个参数n
1
2
3

3、strcat本质上是把目标字符串的’\0’与源字符串的元素交换实现的，当连接的是自己的时候，就 会陷入死循环，那么这时只能使用strncat函数了
建议：建议采用strncat()，因为不会出现上述的陷入死循环的可能，并且strncat()有一个不可或缺的优势，就是能够自由控制要增加的字符个数
模拟实现

#include 
#include
#include 
//dest为前面的字符串，src为后面要加的字符串
//dest因为内存要改变，所以不能加const，而src加上更好
char* My_strcat(char* dest, const char* src)
{
	assert(dest != NULL && src != NULL);  //保证dest、src非空
	char* ret = dest;    //将dest首地址储存在ret中，在之后dest++运算中，可以方便找到
	while (*dest != '\0')  //用指针往后一个个找，找到dest结尾的‘\0’
	   dest++;
	while ((*dest++ = *src++) != '\0')//把src里的字符一个个放入dest后
		;
	return ret;  //返回dest字符串起始地址
}
int main()
{
	char arr1[20] = "I LOVE YOU";
	My_strcat(arr1, " SORRY" );
	//经过函数My_strcat后 ，arr1里应该是字符串I LOVE YOU SORRY
	printf("arr1: %s\n", arr1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

运行结果：

3.strncmp

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

说明：
判断两个字符串大小
1）ACSII码 2）长度
注：区分大小写比较的，如果希望不区分大小写进行字符串比较，可以使用stricmp函数
strncmp()函数首先将str1字符串的第一个字符的ACSII值减去str2第一个字符的ACSII值(自左向右比较前n个字符，直到出现不同的字符或遇’\0’为止)
若差值为零则继续比较下去；若差值不为零，则返回差值。
特别注意： strncmp可用于比较两个字符串常量或比较数组和字符串常量，不能比较数字等其他形式的参数。

与strcmp的区别
1、先比较一下两个函数传参的不同：

 int My_strncmp(const char* str1, const char* str2, int num)
1

int My_strcmp(const char* str1, const char* str2)
1

strcmp与strncmp都是用来比较字符串的，区别在于能否比较指定长度字符串，故要多传一个长度参数，这也使得strncmp比strcmp更加精细。
模拟实现

//以null结尾的字符串 const修饰防止字符串被修改，进行保护
int My_strncmp(const char* str1, const char* str2, int n)
{
	if (!n)   //n=0时，无字符要比，直接return 0
		return 0;
	while (--n && *str1 && *str1 == *str2) //当字符相等且不为’\0‘时比较下个字符，知道n=0比完
	{
		str1++;
		str2++;
	}
	return *str1 - *str2;//字符不相等时，（*str1 - *str2）可以满足返回值正负的需求
}
int main()
{
	char str1[] = "SSOLVE YOU";
	char str2[] = "SORRY";
	printf("%d\n", my_strncmp(str1, str2, 4));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

四.字符串查找

1.strstr

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

返回指向str1中第一个出现的str2的指针，如果str2不是str1的一部分，则返回null指针

使用案例：

//使用strstr
int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";
	int ret = strstr(arr1, arr2);
	if (ret != NULL)
	{
		printf("找到了:%s\n", ret);
	}
	else
	{
		printf("找不到了\n");
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

运行结果：

模拟实现strstr

//模拟实现strstr
char* my_strstr(const char* str1, const char* str2)
{
	char* cp = str1;
	char* s1 = cp;
	char* s2 = str2;
	while (*cp)
	{
		s1 = cp;
		s2 = str2;
		while (*s1 && *s2 && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return cp;
		cp++;
	}
	return NULL;
}
int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";
	int ret = my_strstr(arr1, arr2);
	if (ret != NULL)
	{
		printf("找到了:%s\n", ret);
	}
	else
	{
		printf("找不到了\n");
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

运行结果：

2.strtok

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

1.sep参数是个字符串，定义了用作分隔符的字符集合
2.第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
3.strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：
4.strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
5.strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
6.strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
7.如果字符串中不存在更多的标记，则返回 NULL 指针。

strtok的使用

//strtok的使用
int main()
{
	char arr[] = "zpengwei@yeah.net@666#777";
	char cpy[30];
	strcpy(cpy, arr);
	char* sep = "@.#";
	char* ret = NULL;
	for (ret = strtok(cpy, sep); ret != NULL; ret = strtok(NULL, sep))
	{
		printf("%s\n", ret);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

五.错误信息报告

1.strerror

char * strerror ( int errnum );
1

返回错误码，所对应的错误信息

strerror的使用：

//strerror的使用
int main()
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d:%s\n", i, strerror(i));
	}
}
1
2
3
4
5
6
7
8
9

运行结果：

六.字符操作

七.内存操作函数

1.memcpy

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

1.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
2.这个函数在遇到 ‘\0’ 的时候并不会停下来。
3.如果source和destination有任何的重叠，复制的结果都是未定义的。

//memcpy的使用
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 < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

int main()
{
	float arr1[] = { 1.0,2.0,3.0 };
	float arr2[10] = { 0 };
	memcpy(arr2, arr1, 24);
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%lf ", arr2[i]);
;	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

模拟实现memcpy

//模拟实现memcpy
void* my_memcpy(void* dest, const void* src, int num)
{
	assert(dest && src);
	void* ret = dest;
	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1, 21);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

运行结果：

2.memmove

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

1.和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
2.如果源空间和目标空间出现重叠，就得使用memmove函数处理。

模拟memmove

//模拟memmove
void* my_memmove(void* dest, const void* src, int num)
{
	assert(dest && src);
	void* ret = dest;
	if (dest < src)
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return ret;
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr + 2, arr, 21);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

运行结果：

3.memset

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

int main()
{
	char arr[] = "hello bit";
	memset(arr+1,'x',4);//以字节为单位设置的
	printf("%s\n", arr);
	return 0;
}
1
2
3
4
5
6
7

运行结果：

4.memcmp

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

比较从ptr1和ptr2指针开始的num个字节

int main()
{
	int arr1[] = { 1,2,1,4,5,6 };
	int arr2[] = { 1,2,257 };
	int ret = memcmp(arr1, arr2, 10);
	printf("%d\n", ret);
	return 0;
}
1
2
3
4
5
6
7
8

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

💘不知不觉，字符函数和字符串函数2（C语言进阶）以告一段落。通读全文的你肯定收获满满，让我们继续为C语言学习共同奋进!!!