Error[8]: Undefined offset: 246, File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 114
File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 473, decode(

🍠订阅专栏: 字符串函数

🍅关注博主:翻斗花园第一代码手牛爷爷

目录

 🍍前言

🌽函数介绍

🏡strncpy函数

🍐 strncpy函数使用

🍓strncpy函数模拟实现

🍉strncat函数

🍚 strncat函数使用

🍎strncat函数模拟实现

🍊strncmp函数

🍒strncmp函数使用

 🍭strncmp函数模拟实现

👕strstr函数

👚strstr函数使用

🎸strstr模拟实现

🍚 总结


 

 🍍前言

在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

🌽函数介绍 🏡strncpy函数
[+++]

有限制字符串拷贝函数

🍐 strncpy函数使用

strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

#include 
#include 

int main()
{
	char arr[] = "abcdefg";
	char arr2[] = "****";
	printf("%s\n", strncpy(arr, arr2, 2));
	return 0;
}

我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

 我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

#include 
#include 

int main()
{
	char arr[] = "abcdefg";
	char arr2[] = "****";
	printf("%s\n", strncpy(arr, arr2, 6));
	return 0;
}

运行结果如图:

 单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

 通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上[+++],直到num个。

🍓strncpy函数模拟实现
#include 
#include 

char* my_strncpy(char* arr, char* arr2, int num)
{
	int i = 0;
	for (i = 0; i < num; i++)
	{
		if (*(arr2 + i) != '
') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
'; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
 
🍉strncat函数 

[+++]

有限制字符串追加函数

[+++] 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

[+++]
,下面我们用代码观察strncat函数的具体实现。 
#include 
#include 
int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

我们在通过监视图观察

[+++]

的情况。 如下图:

 通过监视图我们可以观察到,在追加2个字符后会补上一个

[+++]
。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
#include 
#include 
int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

 我们在辅以监视图观察。

 通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

[+++]
。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
🍎strncat函数模拟实现 
#include < num; i++)
	{
		if (*(arr2 + i) != '
') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
'; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include

char* my_strncat(char* arr, char* arr2, int num)
{
	int sz = 0;
	while (*(arr + sz) != '\0')
	{
		sz++;
	}
	for (int i = 0; i 

🍊strncmp函数

[+++]有限制字符串比较函数

[+++][+++]
🍒strncmp函数使用 
strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
#include

#include

int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
 
 🍭strncmp函数模拟实现 
< num; i++)
	{
		if (*(arr + i) != *(arr2 + i))
		{
			return *(arr + i) - *(arr2 + i);
		}
	}
	return 0;
}

int main()
{
	char arr[] = "abcde";
	char arr2[] = "bcde";
	printf("%d\n", my_strncmp(arr, arr2, 3));
	return 0;
}
#include
#include

int my_strncmp(char* arr, char* arr2, int num)
{
	for (int i = 0; i 

👕strstr函数

[+++]字符串查找函数。

[+++][+++]
👚strstr函数使用 
我们使用代码对strstr函数进行分析观察,代码如下: 
#include

#include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

[+++]

的地址,那么打印结果应该为fabcdeabc,运行结果如图。

 
 我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
#include

#include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

[+++]

子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

[+++]

,我们通过运行结果图来进行分析,如下图。

 
 通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
🎸strstr模拟实现 
#include

#include

char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

🍚 总结

本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

<===> <===> <===> <===>)
File: /www/wwwroot/outofmemory.cn/tmp/route_read.php, Line: 126, InsideLink()
File: /www/wwwroot/outofmemory.cn/tmp/index.inc.php, Line: 166, include(/www/wwwroot/outofmemory.cn/tmp/route_read.php)
File: /www/wwwroot/outofmemory.cn/index.php, Line: 30, include(/www/wwwroot/outofmemory.cn/tmp/index.inc.php)
Error[8]: Undefined offset: 247, File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 114
File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 473, decode(

🍠订阅专栏: 字符串函数

🍅关注博主:翻斗花园第一代码手牛爷爷

目录

 🍍前言

🌽函数介绍

🏡strncpy函数

🍐 strncpy函数使用

🍓strncpy函数模拟实现

🍉strncat函数

🍚 strncat函数使用

🍎strncat函数模拟实现

🍊strncmp函数

🍒strncmp函数使用

 🍭strncmp函数模拟实现

👕strstr函数

👚strstr函数使用

🎸strstr模拟实现

🍚 总结


 

 🍍前言

在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

🌽函数介绍 🏡strncpy函数
[+++]

有限制字符串拷贝函数

🍐 strncpy函数使用

strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

#include 
#include 

int main()
{
	char arr[] = "abcdefg";
	char arr2[] = "****";
	printf("%s\n", strncpy(arr, arr2, 2));
	return 0;
}

我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

 我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

#include 
#include 

int main()
{
	char arr[] = "abcdefg";
	char arr2[] = "****";
	printf("%s\n", strncpy(arr, arr2, 6));
	return 0;
}

运行结果如图:

 单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

 通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上[+++],直到num个。

🍓strncpy函数模拟实现
#include 
#include 

char* my_strncpy(char* arr, char* arr2, int num)
{
	int i = 0;
	for (i = 0; i < num; i++)
	{
		if (*(arr2 + i) != '
') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
'; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
 
🍉strncat函数 

[+++]

有限制字符串追加函数

[+++] 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

[+++]
,下面我们用代码观察strncat函数的具体实现。 
#include 
#include 
int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

我们在通过监视图观察

[+++]

的情况。 如下图:

 通过监视图我们可以观察到,在追加2个字符后会补上一个

[+++]
。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
#include 
#include 
int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

 我们在辅以监视图观察。

 通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

[+++]
。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
🍎strncat函数模拟实现 
#include < num; i++)
	{
		if (*(arr2 + i) != '
') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
'; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include

char* my_strncat(char* arr, char* arr2, int num)
{
	int sz = 0;
	while (*(arr + sz) != '\0')
	{
		sz++;
	}
	for (int i = 0; i 

🍊strncmp函数

[+++]有限制字符串比较函数

[+++][+++]
🍒strncmp函数使用 
strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
#include

#include

int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
 
 🍭strncmp函数模拟实现 
< num; i++)
	{
		if (*(arr + i) != *(arr2 + i))
		{
			return *(arr + i) - *(arr2 + i);
		}
	}
	return 0;
}

int main()
{
	char arr[] = "abcde";
	char arr2[] = "bcde";
	printf("%d\n", my_strncmp(arr, arr2, 3));
	return 0;
}
#include
#include

int my_strncmp(char* arr, char* arr2, int num)
{
	for (int i = 0; i 

👕strstr函数

[+++]字符串查找函数。

[+++][+++]
👚strstr函数使用 
我们使用代码对strstr函数进行分析观察,代码如下: 
#include

#include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

[+++]

的地址,那么打印结果应该为fabcdeabc,运行结果如图。

 
 我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
#include

#include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

[+++]

子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

[+++]

,我们通过运行结果图来进行分析,如下图。

 
 通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
🎸strstr模拟实现 
#include

#include

char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

🍚 总结

本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

 <===> <===> <===>)
File: /www/wwwroot/outofmemory.cn/tmp/route_read.php, Line: 126, InsideLink()
File: /www/wwwroot/outofmemory.cn/tmp/index.inc.php, Line: 166, include(/www/wwwroot/outofmemory.cn/tmp/route_read.php)
File: /www/wwwroot/outofmemory.cn/index.php, Line: 30, include(/www/wwwroot/outofmemory.cn/tmp/index.inc.php)
Error[8]: Undefined offset: 248, File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 114
File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 473, decode(

🍠订阅专栏: 字符串函数

🍅关注博主:翻斗花园第一代码手牛爷爷

目录

 🍍前言

🌽函数介绍

🏡strncpy函数

🍐 strncpy函数使用

🍓strncpy函数模拟实现

🍉strncat函数

🍚 strncat函数使用

🍎strncat函数模拟实现

🍊strncmp函数

🍒strncmp函数使用

 🍭strncmp函数模拟实现

👕strstr函数

👚strstr函数使用

🎸strstr模拟实现

🍚 总结


 

 🍍前言

在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

🌽函数介绍 🏡strncpy函数
[+++]

有限制字符串拷贝函数

🍐 strncpy函数使用

strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

#include 
#include 

int main()
{
	char arr[] = "abcdefg";
	char arr2[] = "****";
	printf("%s\n", strncpy(arr, arr2, 2));
	return 0;
}

我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

 我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

#include 
#include 

int main()
{
	char arr[] = "abcdefg";
	char arr2[] = "****";
	printf("%s\n", strncpy(arr, arr2, 6));
	return 0;
}

运行结果如图:

 单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

 通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上[+++],直到num个。

🍓strncpy函数模拟实现
#include 
#include 

char* my_strncpy(char* arr, char* arr2, int num)
{
	int i = 0;
	for (i = 0; i < num; i++)
	{
		if (*(arr2 + i) != '
') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
'; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
 
🍉strncat函数 

[+++]

有限制字符串追加函数

[+++] 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

[+++]
,下面我们用代码观察strncat函数的具体实现。 
#include 
#include 
int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

我们在通过监视图观察

[+++]

的情况。 如下图:

 通过监视图我们可以观察到,在追加2个字符后会补上一个

[+++]
。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
#include 
#include 
int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

 我们在辅以监视图观察。

 通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

[+++]
。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
🍎strncat函数模拟实现 
#include < num; i++)
	{
		if (*(arr2 + i) != '
') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
'; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include

char* my_strncat(char* arr, char* arr2, int num)
{
	int sz = 0;
	while (*(arr + sz) != '\0')
	{
		sz++;
	}
	for (int i = 0; i 

🍊strncmp函数

[+++]有限制字符串比较函数

[+++][+++]
🍒strncmp函数使用 
strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
#include

#include

int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
 
 🍭strncmp函数模拟实现 
< num; i++)
	{
		if (*(arr + i) != *(arr2 + i))
		{
			return *(arr + i) - *(arr2 + i);
		}
	}
	return 0;
}

int main()
{
	char arr[] = "abcde";
	char arr2[] = "bcde";
	printf("%d\n", my_strncmp(arr, arr2, 3));
	return 0;
}
#include
#include

int my_strncmp(char* arr, char* arr2, int num)
{
	for (int i = 0; i 

👕strstr函数

[+++]字符串查找函数。

[+++][+++]
👚strstr函数使用 
我们使用代码对strstr函数进行分析观察,代码如下: 
#include

#include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

[+++]

的地址,那么打印结果应该为fabcdeabc,运行结果如图。

 
 我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
#include

#include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

[+++]

子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

[+++]

,我们通过运行结果图来进行分析,如下图。

 
 通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
🎸strstr模拟实现 
#include

#include

char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

🍚 总结

本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

  <===> <===>)
File: /www/wwwroot/outofmemory.cn/tmp/route_read.php, Line: 126, InsideLink()
File: /www/wwwroot/outofmemory.cn/tmp/index.inc.php, Line: 166, include(/www/wwwroot/outofmemory.cn/tmp/route_read.php)
File: /www/wwwroot/outofmemory.cn/index.php, Line: 30, include(/www/wwwroot/outofmemory.cn/tmp/index.inc.php)
Error[8]: Undefined offset: 249, File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 114
File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 473, decode(

🍠订阅专栏: 字符串函数

🍅关注博主:翻斗花园第一代码手牛爷爷

目录

 🍍前言

🌽函数介绍

🏡strncpy函数

🍐 strncpy函数使用

🍓strncpy函数模拟实现

🍉strncat函数

🍚 strncat函数使用

🍎strncat函数模拟实现

🍊strncmp函数

🍒strncmp函数使用

 🍭strncmp函数模拟实现

👕strstr函数

👚strstr函数使用

🎸strstr模拟实现

🍚 总结


 

 🍍前言

在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

🌽函数介绍 🏡strncpy函数
[+++]

有限制字符串拷贝函数

🍐 strncpy函数使用

strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

#include 
#include 

int main()
{
	char arr[] = "abcdefg";
	char arr2[] = "****";
	printf("%s\n", strncpy(arr, arr2, 2));
	return 0;
}

我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

 我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

#include 
#include 

int main()
{
	char arr[] = "abcdefg";
	char arr2[] = "****";
	printf("%s\n", strncpy(arr, arr2, 6));
	return 0;
}

运行结果如图:

 单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

 通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上[+++],直到num个。

🍓strncpy函数模拟实现
#include 
#include 

char* my_strncpy(char* arr, char* arr2, int num)
{
	int i = 0;
	for (i = 0; i < num; i++)
	{
		if (*(arr2 + i) != '
') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
'; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
 
🍉strncat函数 

[+++]

有限制字符串追加函数

[+++] 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

[+++]
,下面我们用代码观察strncat函数的具体实现。 
#include 
#include 
int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

我们在通过监视图观察

[+++]

的情况。 如下图:

 通过监视图我们可以观察到,在追加2个字符后会补上一个

[+++]
。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
#include 
#include 
int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

 我们在辅以监视图观察。

 通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

[+++]
。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
🍎strncat函数模拟实现 
#include < num; i++)
	{
		if (*(arr2 + i) != '
') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
'; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include

char* my_strncat(char* arr, char* arr2, int num)
{
	int sz = 0;
	while (*(arr + sz) != '\0')
	{
		sz++;
	}
	for (int i = 0; i 

🍊strncmp函数

[+++]有限制字符串比较函数

[+++][+++]
🍒strncmp函数使用 
strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
#include

#include

int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
 
 🍭strncmp函数模拟实现 
< num; i++)
	{
		if (*(arr + i) != *(arr2 + i))
		{
			return *(arr + i) - *(arr2 + i);
		}
	}
	return 0;
}

int main()
{
	char arr[] = "abcde";
	char arr2[] = "bcde";
	printf("%d\n", my_strncmp(arr, arr2, 3));
	return 0;
}
#include
#include

int my_strncmp(char* arr, char* arr2, int num)
{
	for (int i = 0; i 

👕strstr函数

[+++]字符串查找函数。

[+++][+++]
👚strstr函数使用 
我们使用代码对strstr函数进行分析观察,代码如下: 
#include

#include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

[+++]

的地址,那么打印结果应该为fabcdeabc,运行结果如图。

 
 我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
#include

#include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

[+++]

子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

[+++]

,我们通过运行结果图来进行分析,如下图。

 
 通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
🎸strstr模拟实现 
#include

#include

char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

🍚 总结

本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

   <===>)
File: /www/wwwroot/outofmemory.cn/tmp/route_read.php, Line: 126, InsideLink()
File: /www/wwwroot/outofmemory.cn/tmp/index.inc.php, Line: 166, include(/www/wwwroot/outofmemory.cn/tmp/route_read.php)
File: /www/wwwroot/outofmemory.cn/index.php, Line: 30, include(/www/wwwroot/outofmemory.cn/tmp/index.inc.php)
Error[8]: Undefined offset: 22, File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 121
File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 473, decode(

🍠订阅专栏: 字符串函数

🍅关注博主:翻斗花园第一代码手牛爷爷

目录

 🍍前言

🌽函数介绍

🏡strncpy函数

🍐 strncpy函数使用

🍓strncpy函数模拟实现

🍉strncat函数

🍚 strncat函数使用

🍎strncat函数模拟实现

🍊strncmp函数

🍒strncmp函数使用

 🍭strncmp函数模拟实现

👕strstr函数

👚strstr函数使用

🎸strstr模拟实现

🍚 总结


 

 🍍前言

在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

🌽函数介绍 🏡strncpy函数
char * strncpy ( char * destination, const char * source, size_t num );

有限制字符串拷贝函数

🍐 strncpy函数使用

strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

#include 
#include 

int main()
{
	char arr[] = "abcdefg";
	char arr2[] = "****";
	printf("%s\n", strncpy(arr, arr2, 2));
	return 0;
}

我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

 我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

#include 
#include 

int main()
{
	char arr[] = "abcdefg";
	char arr2[] = "****";
	printf("%s\n", strncpy(arr, arr2, 6));
	return 0;
}

运行结果如图:

 单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

 通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上

  • 目标空间必须足够大,能够存放下源字符串的内容。
  • ,直到num个。

    🍓strncpy函数模拟实现
    #include 
    #include 
    
    char* my_strncpy(char* arr, char* arr2, int num)
    {
    	int i = 0;
    	for (i = 0; i < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
    '; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
     
    🍉strncat函数 
    

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

    有限制字符串追加函数

  •  在一个字符串中查找另一个字符串,如果存在,返回查找到的字符串的首字符地址,如果不存在,返回空指针。
  • 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

  • 如果查找到的子串存在多份,则返回第一次出现的字符串的首字符地址。
  • ,下面我们用代码观察strncat函数的具体实现。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

    我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

    我们在通过监视图观察

    f

    的情况。 如下图:

     通过监视图我们可以观察到,在追加2个字符后会补上一个

    fab
    。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

    我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

     我们在辅以监视图观察。

     通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

    fabcdefabc
    。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
    🍎strncat函数模拟实现 
    #include < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
    '; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include
    
    char* my_strncat(char* arr, char* arr2, int num)
    {
    	int sz = 0;
    	while (*(arr + sz) != '\0')
    	{
    		sz++;
    	}
    	for (int i = 0; i 

    🍊strncmp函数

    [+++]有限制字符串比较函数

    [+++][+++]
    🍒strncmp函数使用 
    strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
    
    #include

    #include

    int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

    我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
     
     🍭strncmp函数模拟实现 
    < num; i++)
    	{
    		if (*(arr + i) != *(arr2 + i))
    		{
    			return *(arr + i) - *(arr2 + i);
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    	char arr[] = "abcde";
    	char arr2[] = "bcde";
    	printf("%d\n", my_strncmp(arr, arr2, 3));
    	return 0;
    }
    #include
    #include
    
    int my_strncmp(char* arr, char* arr2, int num)
    {
    	for (int i = 0; i 

    👕strstr函数

    [+++]字符串查找函数。

    [+++][+++]
    👚strstr函数使用 
    我们使用代码对strstr函数进行分析观察,代码如下: 
    
    #include

    #include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

    我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

    [+++]

    的地址,那么打印结果应该为fabcdeabc,运行结果如图。

     
     我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
    
    #include

    #include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

    [+++]

    子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

    [+++]

    ,我们通过运行结果图来进行分析,如下图。

     
     通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
    🎸strstr模拟实现 
    
    #include

    #include

    char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

    🍚 总结

    本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

       )
    File: /www/wwwroot/outofmemory.cn/tmp/route_read.php, Line: 126, InsideLink()
    File: /www/wwwroot/outofmemory.cn/tmp/index.inc.php, Line: 166, include(/www/wwwroot/outofmemory.cn/tmp/route_read.php)
    File: /www/wwwroot/outofmemory.cn/index.php, Line: 30, include(/www/wwwroot/outofmemory.cn/tmp/index.inc.php)
    Error[8]: Undefined offset: 23, File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 121
    File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 473, decode(

    🍠订阅专栏: 字符串函数

    🍅关注博主:翻斗花园第一代码手牛爷爷

    目录

     🍍前言

    🌽函数介绍

    🏡strncpy函数

    🍐 strncpy函数使用

    🍓strncpy函数模拟实现

    🍉strncat函数

    🍚 strncat函数使用

    🍎strncat函数模拟实现

    🍊strncmp函数

    🍒strncmp函数使用

     🍭strncmp函数模拟实现

    👕strstr函数

    👚strstr函数使用

    🎸strstr模拟实现

    🍚 总结


     

     🍍前言

    在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

    🌽函数介绍 🏡strncpy函数
    char * strncpy ( char * destination, const char * source, size_t num );

    有限制字符串拷贝函数

    🍐 strncpy函数使用

    strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 2));
    	return 0;
    }

    我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

     我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 6));
    	return 0;
    }

    运行结果如图:

     单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

     通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上

  • 目标空间必须足够大,能够存放下源字符串的内容。
  • ,直到num个。

    🍓strncpy函数模拟实现
    #include 
    #include 
    
    char* my_strncpy(char* arr, char* arr2, int num)
    {
    	int i = 0;
    	for (i = 0; i < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
    '; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
     
    🍉strncat函数 
    

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

    有限制字符串追加函数

  •  在一个字符串中查找另一个字符串,如果存在,返回查找到的字符串的首字符地址,如果不存在,返回空指针。
  • 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

  • 如果查找到的子串存在多份,则返回第一次出现的字符串的首字符地址。
  • ,下面我们用代码观察strncat函数的具体实现。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

    我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

    我们在通过监视图观察

    f

    的情况。 如下图:

     通过监视图我们可以观察到,在追加2个字符后会补上一个

    fab
    。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

    我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

     我们在辅以监视图观察。

     通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

    fabcdefabc
    。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
    🍎strncat函数模拟实现 
    #include < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
    '; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include
    
    char* my_strncat(char* arr, char* arr2, int num)
    {
    	int sz = 0;
    	while (*(arr + sz) != '\0')
    	{
    		sz++;
    	}
    	for (int i = 0; i 

    🍊strncmp函数

    有限制字符串比较函数

    [+++][+++]
    🍒strncmp函数使用 
    strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
    
    #include

    #include

    int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

    我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
     
     🍭strncmp函数模拟实现 
    < num; i++)
    	{
    		if (*(arr + i) != *(arr2 + i))
    		{
    			return *(arr + i) - *(arr2 + i);
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    	char arr[] = "abcde";
    	char arr2[] = "bcde";
    	printf("%d\n", my_strncmp(arr, arr2, 3));
    	return 0;
    }
    #include
    #include
    
    int my_strncmp(char* arr, char* arr2, int num)
    {
    	for (int i = 0; i 

    👕strstr函数

    [+++]字符串查找函数。

    [+++][+++]
    👚strstr函数使用 
    我们使用代码对strstr函数进行分析观察,代码如下: 
    
    #include

    #include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

    我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

    [+++]

    的地址,那么打印结果应该为fabcdeabc,运行结果如图。

     
     我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
    
    #include

    #include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

    [+++]

    子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

    [+++]

    ,我们通过运行结果图来进行分析,如下图。

     
     通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
    🎸strstr模拟实现 
    
    #include

    #include

    char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

    🍚 总结

    本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

       )
    File: /www/wwwroot/outofmemory.cn/tmp/route_read.php, Line: 126, InsideLink()
    File: /www/wwwroot/outofmemory.cn/tmp/index.inc.php, Line: 166, include(/www/wwwroot/outofmemory.cn/tmp/route_read.php)
    File: /www/wwwroot/outofmemory.cn/index.php, Line: 30, include(/www/wwwroot/outofmemory.cn/tmp/index.inc.php)
    Error[8]: Undefined offset: 24, File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 121
    File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 473, decode(

    🍠订阅专栏: 字符串函数

    🍅关注博主:翻斗花园第一代码手牛爷爷

    目录

     🍍前言

    🌽函数介绍

    🏡strncpy函数

    🍐 strncpy函数使用

    🍓strncpy函数模拟实现

    🍉strncat函数

    🍚 strncat函数使用

    🍎strncat函数模拟实现

    🍊strncmp函数

    🍒strncmp函数使用

     🍭strncmp函数模拟实现

    👕strstr函数

    👚strstr函数使用

    🎸strstr模拟实现

    🍚 总结


     

     🍍前言

    在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

    🌽函数介绍 🏡strncpy函数
    char * strncpy ( char * destination, const char * source, size_t num );

    有限制字符串拷贝函数

    🍐 strncpy函数使用

    strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 2));
    	return 0;
    }

    我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

     我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 6));
    	return 0;
    }

    运行结果如图:

     单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

     通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上

  • 目标空间必须足够大,能够存放下源字符串的内容。
  • ,直到num个。

    🍓strncpy函数模拟实现
    #include 
    #include 
    
    char* my_strncpy(char* arr, char* arr2, int num)
    {
    	int i = 0;
    	for (i = 0; i < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
    '; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
     
    🍉strncat函数 
    

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

    有限制字符串追加函数

  •  在一个字符串中查找另一个字符串,如果存在,返回查找到的字符串的首字符地址,如果不存在,返回空指针。
  • 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

  • 如果查找到的子串存在多份,则返回第一次出现的字符串的首字符地址。
  • ,下面我们用代码观察strncat函数的具体实现。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

    我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

    我们在通过监视图观察

    f

    的情况。 如下图:

     通过监视图我们可以观察到,在追加2个字符后会补上一个

    fab
    。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

    我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

     我们在辅以监视图观察。

     通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

    fabcdefabc
    。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
    🍎strncat函数模拟实现 
    #include < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
    '; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include
    
    char* my_strncat(char* arr, char* arr2, int num)
    {
    	int sz = 0;
    	while (*(arr + sz) != '\0')
    	{
    		sz++;
    	}
    	for (int i = 0; i 

    🍊strncmp函数

    有限制字符串比较函数

    [+++]
    🍒strncmp函数使用 
    strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
    
    #include

    #include

    int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

    我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
     
     🍭strncmp函数模拟实现 
    < num; i++)
    	{
    		if (*(arr + i) != *(arr2 + i))
    		{
    			return *(arr + i) - *(arr2 + i);
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    	char arr[] = "abcde";
    	char arr2[] = "bcde";
    	printf("%d\n", my_strncmp(arr, arr2, 3));
    	return 0;
    }
    #include
    #include
    
    int my_strncmp(char* arr, char* arr2, int num)
    {
    	for (int i = 0; i 

    👕strstr函数

    [+++]字符串查找函数。

    [+++][+++]
    👚strstr函数使用 
    我们使用代码对strstr函数进行分析观察,代码如下: 
    
    #include

    #include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

    我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

    [+++]

    的地址,那么打印结果应该为fabcdeabc,运行结果如图。

     
     我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
    
    #include

    #include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

    [+++]

    子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

    [+++]

    ,我们通过运行结果图来进行分析,如下图。

     
     通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
    🎸strstr模拟实现 
    
    #include

    #include

    char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

    🍚 总结

    本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

       )
    File: /www/wwwroot/outofmemory.cn/tmp/route_read.php, Line: 126, InsideLink()
    File: /www/wwwroot/outofmemory.cn/tmp/index.inc.php, Line: 166, include(/www/wwwroot/outofmemory.cn/tmp/route_read.php)
    File: /www/wwwroot/outofmemory.cn/index.php, Line: 30, include(/www/wwwroot/outofmemory.cn/tmp/index.inc.php)
    Error[8]: Undefined offset: 25, File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 121
    File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 473, decode(

    🍠订阅专栏: 字符串函数

    🍅关注博主:翻斗花园第一代码手牛爷爷

    目录

     🍍前言

    🌽函数介绍

    🏡strncpy函数

    🍐 strncpy函数使用

    🍓strncpy函数模拟实现

    🍉strncat函数

    🍚 strncat函数使用

    🍎strncat函数模拟实现

    🍊strncmp函数

    🍒strncmp函数使用

     🍭strncmp函数模拟实现

    👕strstr函数

    👚strstr函数使用

    🎸strstr模拟实现

    🍚 总结


     

     🍍前言

    在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

    🌽函数介绍 🏡strncpy函数
    char * strncpy ( char * destination, const char * source, size_t num );

    有限制字符串拷贝函数

    🍐 strncpy函数使用

    strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 2));
    	return 0;
    }

    我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

     我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 6));
    	return 0;
    }

    运行结果如图:

     单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

     通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上

  • 目标空间必须足够大,能够存放下源字符串的内容。
  • ,直到num个。

    🍓strncpy函数模拟实现
    #include 
    #include 
    
    char* my_strncpy(char* arr, char* arr2, int num)
    {
    	int i = 0;
    	for (i = 0; i < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
    '; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
     
    🍉strncat函数 
    

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

    有限制字符串追加函数

  •  在一个字符串中查找另一个字符串,如果存在,返回查找到的字符串的首字符地址,如果不存在,返回空指针。
  • 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

  • 如果查找到的子串存在多份,则返回第一次出现的字符串的首字符地址。
  • ,下面我们用代码观察strncat函数的具体实现。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

    我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

    我们在通过监视图观察

    f

    的情况。 如下图:

     通过监视图我们可以观察到,在追加2个字符后会补上一个

    fab
    。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

    我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

     我们在辅以监视图观察。

     通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

    fabcdefabc
    。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
    🍎strncat函数模拟实现 
    #include < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
    '; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include
    
    char* my_strncat(char* arr, char* arr2, int num)
    {
    	int sz = 0;
    	while (*(arr + sz) != '\0')
    	{
    		sz++;
    	}
    	for (int i = 0; i 

    🍊strncmp函数

    有限制字符串比较函数

    
    🍒strncmp函数使用 
    strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
    
    #include

    #include

    int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

    我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
     
     🍭strncmp函数模拟实现 
    < num; i++)
    	{
    		if (*(arr + i) != *(arr2 + i))
    		{
    			return *(arr + i) - *(arr2 + i);
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    	char arr[] = "abcde";
    	char arr2[] = "bcde";
    	printf("%d\n", my_strncmp(arr, arr2, 3));
    	return 0;
    }
    #include
    #include
    
    int my_strncmp(char* arr, char* arr2, int num)
    {
    	for (int i = 0; i 

    👕strstr函数

    [+++]字符串查找函数。

    [+++][+++]
    👚strstr函数使用 
    我们使用代码对strstr函数进行分析观察,代码如下: 
    
    #include

    #include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

    我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

    [+++]

    的地址,那么打印结果应该为fabcdeabc,运行结果如图。

     
     我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
    
    #include

    #include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

    [+++]

    子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

    [+++]

    ,我们通过运行结果图来进行分析,如下图。

     
     通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
    🎸strstr模拟实现 
    
    #include

    #include

    char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

    🍚 总结

    本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

       )
    File: /www/wwwroot/outofmemory.cn/tmp/route_read.php, Line: 126, InsideLink()
    File: /www/wwwroot/outofmemory.cn/tmp/index.inc.php, Line: 166, include(/www/wwwroot/outofmemory.cn/tmp/route_read.php)
    File: /www/wwwroot/outofmemory.cn/index.php, Line: 30, include(/www/wwwroot/outofmemory.cn/tmp/index.inc.php)
    Error[8]: Undefined offset: 26, File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 121
    File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 473, decode(

    🍠订阅专栏: 字符串函数

    🍅关注博主:翻斗花园第一代码手牛爷爷

    目录

     🍍前言

    🌽函数介绍

    🏡strncpy函数

    🍐 strncpy函数使用

    🍓strncpy函数模拟实现

    🍉strncat函数

    🍚 strncat函数使用

    🍎strncat函数模拟实现

    🍊strncmp函数

    🍒strncmp函数使用

     🍭strncmp函数模拟实现

    👕strstr函数

    👚strstr函数使用

    🎸strstr模拟实现

    🍚 总结


     

     🍍前言

    在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

    🌽函数介绍 🏡strncpy函数
    char * strncpy ( char * destination, const char * source, size_t num );

    有限制字符串拷贝函数

    🍐 strncpy函数使用

    strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 2));
    	return 0;
    }

    我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

     我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 6));
    	return 0;
    }

    运行结果如图:

     单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

     通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上

  • 目标空间必须足够大,能够存放下源字符串的内容。
  • ,直到num个。

    🍓strncpy函数模拟实现
    #include 
    #include 
    
    char* my_strncpy(char* arr, char* arr2, int num)
    {
    	int i = 0;
    	for (i = 0; i < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
    '; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
     
    🍉strncat函数 
    

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

    有限制字符串追加函数

  •  在一个字符串中查找另一个字符串,如果存在,返回查找到的字符串的首字符地址,如果不存在,返回空指针。
  • 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

  • 如果查找到的子串存在多份,则返回第一次出现的字符串的首字符地址。
  • ,下面我们用代码观察strncat函数的具体实现。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

    我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

    我们在通过监视图观察

    f

    的情况。 如下图:

     通过监视图我们可以观察到,在追加2个字符后会补上一个

    fab
    。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

    我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

     我们在辅以监视图观察。

     通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

    fabcdefabc
    。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
    🍎strncat函数模拟实现 
    #include < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
    '; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include
    
    char* my_strncat(char* arr, char* arr2, int num)
    {
    	int sz = 0;
    	while (*(arr + sz) != '\0')
    	{
    		sz++;
    	}
    	for (int i = 0; i 

    🍊strncmp函数

    有限制字符串比较函数

    
    🍒strncmp函数使用 
    strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
    
    #include

    #include

    int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

    我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
     
     🍭strncmp函数模拟实现 
    < num; i++)
    	{
    		if (*(arr + i) != *(arr2 + i))
    		{
    			return *(arr + i) - *(arr2 + i);
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    	char arr[] = "abcde";
    	char arr2[] = "bcde";
    	printf("%d\n", my_strncmp(arr, arr2, 3));
    	return 0;
    }
    #include
    #include
    
    int my_strncmp(char* arr, char* arr2, int num)
    {
    	for (int i = 0; i 

    👕strstr函数

    字符串查找函数。

    [+++][+++]
    👚strstr函数使用 
    我们使用代码对strstr函数进行分析观察,代码如下: 
    
    #include

    #include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

    我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

    [+++]

    的地址,那么打印结果应该为fabcdeabc,运行结果如图。

     
     我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
    
    #include

    #include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

    [+++]

    子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

    [+++]

    ,我们通过运行结果图来进行分析,如下图。

     
     通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
    🎸strstr模拟实现 
    
    #include

    #include

    char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

    🍚 总结

    本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

       )
    File: /www/wwwroot/outofmemory.cn/tmp/route_read.php, Line: 126, InsideLink()
    File: /www/wwwroot/outofmemory.cn/tmp/index.inc.php, Line: 166, include(/www/wwwroot/outofmemory.cn/tmp/route_read.php)
    File: /www/wwwroot/outofmemory.cn/index.php, Line: 30, include(/www/wwwroot/outofmemory.cn/tmp/index.inc.php)
    Error[8]: Undefined offset: 27, File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 121
    File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 473, decode(

    🍠订阅专栏: 字符串函数

    🍅关注博主:翻斗花园第一代码手牛爷爷

    目录

     🍍前言

    🌽函数介绍

    🏡strncpy函数

    🍐 strncpy函数使用

    🍓strncpy函数模拟实现

    🍉strncat函数

    🍚 strncat函数使用

    🍎strncat函数模拟实现

    🍊strncmp函数

    🍒strncmp函数使用

     🍭strncmp函数模拟实现

    👕strstr函数

    👚strstr函数使用

    🎸strstr模拟实现

    🍚 总结


     

     🍍前言

    在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

    🌽函数介绍 🏡strncpy函数
    char * strncpy ( char * destination, const char * source, size_t num );

    有限制字符串拷贝函数

    🍐 strncpy函数使用

    strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 2));
    	return 0;
    }

    我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

     我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 6));
    	return 0;
    }

    运行结果如图:

     单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

     通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上

  • 目标空间必须足够大,能够存放下源字符串的内容。
  • ,直到num个。

    🍓strncpy函数模拟实现
    #include 
    #include 
    
    char* my_strncpy(char* arr, char* arr2, int num)
    {
    	int i = 0;
    	for (i = 0; i < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
    '; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
     
    🍉strncat函数 
    

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

    有限制字符串追加函数

  •  在一个字符串中查找另一个字符串,如果存在,返回查找到的字符串的首字符地址,如果不存在,返回空指针。
  • 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

  • 如果查找到的子串存在多份,则返回第一次出现的字符串的首字符地址。
  • ,下面我们用代码观察strncat函数的具体实现。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

    我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

    我们在通过监视图观察

    f

    的情况。 如下图:

     通过监视图我们可以观察到,在追加2个字符后会补上一个

    fab
    。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

    我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

     我们在辅以监视图观察。

     通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

    fabcdefabc
    。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
    🍎strncat函数模拟实现 
    #include < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
    '; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include
    
    char* my_strncat(char* arr, char* arr2, int num)
    {
    	int sz = 0;
    	while (*(arr + sz) != '\0')
    	{
    		sz++;
    	}
    	for (int i = 0; i 

    🍊strncmp函数

    有限制字符串比较函数

    
    🍒strncmp函数使用 
    strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
    
    #include

    #include

    int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

    我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
     
     🍭strncmp函数模拟实现 
    < num; i++)
    	{
    		if (*(arr + i) != *(arr2 + i))
    		{
    			return *(arr + i) - *(arr2 + i);
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    	char arr[] = "abcde";
    	char arr2[] = "bcde";
    	printf("%d\n", my_strncmp(arr, arr2, 3));
    	return 0;
    }
    #include
    #include
    
    int my_strncmp(char* arr, char* arr2, int num)
    {
    	for (int i = 0; i 

    👕strstr函数

    字符串查找函数。

    [+++]
    👚strstr函数使用 
    我们使用代码对strstr函数进行分析观察,代码如下: 
    
    #include

    #include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

    我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

    [+++]

    的地址,那么打印结果应该为fabcdeabc,运行结果如图。

     
     我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
    
    #include

    #include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

    [+++]

    子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

    [+++]

    ,我们通过运行结果图来进行分析,如下图。

     
     通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
    🎸strstr模拟实现 
    
    #include

    #include

    char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

    🍚 总结

    本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

       )
    File: /www/wwwroot/outofmemory.cn/tmp/route_read.php, Line: 126, InsideLink()
    File: /www/wwwroot/outofmemory.cn/tmp/index.inc.php, Line: 166, include(/www/wwwroot/outofmemory.cn/tmp/route_read.php)
    File: /www/wwwroot/outofmemory.cn/index.php, Line: 30, include(/www/wwwroot/outofmemory.cn/tmp/index.inc.php)
    Error[8]: Undefined offset: 28, File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 121
    File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 473, decode(

    🍠订阅专栏: 字符串函数

    🍅关注博主:翻斗花园第一代码手牛爷爷

    目录

     🍍前言

    🌽函数介绍

    🏡strncpy函数

    🍐 strncpy函数使用

    🍓strncpy函数模拟实现

    🍉strncat函数

    🍚 strncat函数使用

    🍎strncat函数模拟实现

    🍊strncmp函数

    🍒strncmp函数使用

     🍭strncmp函数模拟实现

    👕strstr函数

    👚strstr函数使用

    🎸strstr模拟实现

    🍚 总结


     

     🍍前言

    在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

    🌽函数介绍 🏡strncpy函数
    char * strncpy ( char * destination, const char * source, size_t num );

    有限制字符串拷贝函数

    🍐 strncpy函数使用

    strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 2));
    	return 0;
    }

    我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

     我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 6));
    	return 0;
    }

    运行结果如图:

     单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

     通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上

  • 目标空间必须足够大,能够存放下源字符串的内容。
  • ,直到num个。

    🍓strncpy函数模拟实现
    #include 
    #include 
    
    char* my_strncpy(char* arr, char* arr2, int num)
    {
    	int i = 0;
    	for (i = 0; i < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
    '; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
     
    🍉strncat函数 
    

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

    有限制字符串追加函数

  •  在一个字符串中查找另一个字符串,如果存在,返回查找到的字符串的首字符地址,如果不存在,返回空指针。
  • 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

  • 如果查找到的子串存在多份,则返回第一次出现的字符串的首字符地址。
  • ,下面我们用代码观察strncat函数的具体实现。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

    我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

    我们在通过监视图观察

    f

    的情况。 如下图:

     通过监视图我们可以观察到,在追加2个字符后会补上一个

    fab
    。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

    我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

     我们在辅以监视图观察。

     通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

    fabcdefabc
    。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
    🍎strncat函数模拟实现 
    #include < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
    '; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include
    
    char* my_strncat(char* arr, char* arr2, int num)
    {
    	int sz = 0;
    	while (*(arr + sz) != '\0')
    	{
    		sz++;
    	}
    	for (int i = 0; i 

    🍊strncmp函数

    有限制字符串比较函数

    
    🍒strncmp函数使用 
    strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
    
    #include

    #include

    int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

    我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
     
     🍭strncmp函数模拟实现 
    < num; i++)
    	{
    		if (*(arr + i) != *(arr2 + i))
    		{
    			return *(arr + i) - *(arr2 + i);
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    	char arr[] = "abcde";
    	char arr2[] = "bcde";
    	printf("%d\n", my_strncmp(arr, arr2, 3));
    	return 0;
    }
    #include
    #include
    
    int my_strncmp(char* arr, char* arr2, int num)
    {
    	for (int i = 0; i 

    👕strstr函数

    字符串查找函数。

    
    👚strstr函数使用 
    我们使用代码对strstr函数进行分析观察,代码如下: 
    
    #include

    #include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

    我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

    [+++]

    的地址,那么打印结果应该为fabcdeabc,运行结果如图。

     
     我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
    
    #include

    #include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

    [+++]

    子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

    [+++]

    ,我们通过运行结果图来进行分析,如下图。

     
     通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
    🎸strstr模拟实现 
    
    #include

    #include

    char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

    🍚 总结

    本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

       )
    File: /www/wwwroot/outofmemory.cn/tmp/route_read.php, Line: 126, InsideLink()
    File: /www/wwwroot/outofmemory.cn/tmp/index.inc.php, Line: 166, include(/www/wwwroot/outofmemory.cn/tmp/route_read.php)
    File: /www/wwwroot/outofmemory.cn/index.php, Line: 30, include(/www/wwwroot/outofmemory.cn/tmp/index.inc.php)
    Error[8]: Undefined offset: 29, File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 121
    File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 473, decode(

    🍠订阅专栏: 字符串函数

    🍅关注博主:翻斗花园第一代码手牛爷爷

    目录

     🍍前言

    🌽函数介绍

    🏡strncpy函数

    🍐 strncpy函数使用

    🍓strncpy函数模拟实现

    🍉strncat函数

    🍚 strncat函数使用

    🍎strncat函数模拟实现

    🍊strncmp函数

    🍒strncmp函数使用

     🍭strncmp函数模拟实现

    👕strstr函数

    👚strstr函数使用

    🎸strstr模拟实现

    🍚 总结


     

     🍍前言

    在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

    🌽函数介绍 🏡strncpy函数
    char * strncpy ( char * destination, const char * source, size_t num );

    有限制字符串拷贝函数

    🍐 strncpy函数使用

    strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 2));
    	return 0;
    }

    我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

     我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 6));
    	return 0;
    }

    运行结果如图:

     单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

     通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上

  • 目标空间必须足够大,能够存放下源字符串的内容。
  • ,直到num个。

    🍓strncpy函数模拟实现
    #include 
    #include 
    
    char* my_strncpy(char* arr, char* arr2, int num)
    {
    	int i = 0;
    	for (i = 0; i < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
    '; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
     
    🍉strncat函数 
    

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

    有限制字符串追加函数

  •  在一个字符串中查找另一个字符串,如果存在,返回查找到的字符串的首字符地址,如果不存在,返回空指针。
  • 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

  • 如果查找到的子串存在多份,则返回第一次出现的字符串的首字符地址。
  • ,下面我们用代码观察strncat函数的具体实现。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

    我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

    我们在通过监视图观察

    f

    的情况。 如下图:

     通过监视图我们可以观察到,在追加2个字符后会补上一个

    fab
    。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

    我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

     我们在辅以监视图观察。

     通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

    fabcdefabc
    。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
    🍎strncat函数模拟实现 
    #include < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
    '; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include
    
    char* my_strncat(char* arr, char* arr2, int num)
    {
    	int sz = 0;
    	while (*(arr + sz) != '\0')
    	{
    		sz++;
    	}
    	for (int i = 0; i 

    🍊strncmp函数

    有限制字符串比较函数

    
    🍒strncmp函数使用 
    strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
    
    #include

    #include

    int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

    我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
     
     🍭strncmp函数模拟实现 
    < num; i++)
    	{
    		if (*(arr + i) != *(arr2 + i))
    		{
    			return *(arr + i) - *(arr2 + i);
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    	char arr[] = "abcde";
    	char arr2[] = "bcde";
    	printf("%d\n", my_strncmp(arr, arr2, 3));
    	return 0;
    }
    #include
    #include
    
    int my_strncmp(char* arr, char* arr2, int num)
    {
    	for (int i = 0; i 

    👕strstr函数

    字符串查找函数。

    
    👚strstr函数使用 
    我们使用代码对strstr函数进行分析观察,代码如下: 
    
    #include

    #include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

    我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

    的地址,那么打印结果应该为fabcdeabc,运行结果如图。

     
     我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
    
    #include

    #include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

    [+++]

    子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

    [+++]

    ,我们通过运行结果图来进行分析,如下图。

     
     通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
    🎸strstr模拟实现 
    
    #include

    #include

    char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

    🍚 总结

    本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

       )
    File: /www/wwwroot/outofmemory.cn/tmp/route_read.php, Line: 126, InsideLink()
    File: /www/wwwroot/outofmemory.cn/tmp/index.inc.php, Line: 166, include(/www/wwwroot/outofmemory.cn/tmp/route_read.php)
    File: /www/wwwroot/outofmemory.cn/index.php, Line: 30, include(/www/wwwroot/outofmemory.cn/tmp/index.inc.php)
    Error[8]: Undefined offset: 30, File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 121
    File: /www/wwwroot/outofmemory.cn/tmp/plugin_ss_superseo_model_superseo.php, Line: 473, decode(

    🍠订阅专栏: 字符串函数

    🍅关注博主:翻斗花园第一代码手牛爷爷

    目录

     🍍前言

    🌽函数介绍

    🏡strncpy函数

    🍐 strncpy函数使用

    🍓strncpy函数模拟实现

    🍉strncat函数

    🍚 strncat函数使用

    🍎strncat函数模拟实现

    🍊strncmp函数

    🍒strncmp函数使用

     🍭strncmp函数模拟实现

    👕strstr函数

    👚strstr函数使用

    🎸strstr模拟实现

    🍚 总结


     

     🍍前言

    在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

    🌽函数介绍 🏡strncpy函数
    char * strncpy ( char * destination, const char * source, size_t num );

    有限制字符串拷贝函数

    🍐 strncpy函数使用

    strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 2));
    	return 0;
    }

    我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

     我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 6));
    	return 0;
    }

    运行结果如图:

     单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

     通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上

  • 目标空间必须足够大,能够存放下源字符串的内容。
  • ,直到num个。

    🍓strncpy函数模拟实现
    #include 
    #include 
    
    char* my_strncpy(char* arr, char* arr2, int num)
    {
    	int i = 0;
    	for (i = 0; i < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
    '; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
     
    🍉strncat函数 
    

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

    有限制字符串追加函数

  •  在一个字符串中查找另一个字符串,如果存在,返回查找到的字符串的首字符地址,如果不存在,返回空指针。
  • 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

  • 如果查找到的子串存在多份,则返回第一次出现的字符串的首字符地址。
  • ,下面我们用代码观察strncat函数的具体实现。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

    我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

    我们在通过监视图观察

    f

    的情况。 如下图:

     通过监视图我们可以观察到,在追加2个字符后会补上一个

    fab
    。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

    我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

     我们在辅以监视图观察。

     通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

    fabcdefabc
    。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
    🍎strncat函数模拟实现 
    #include < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
    '; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include
    
    char* my_strncat(char* arr, char* arr2, int num)
    {
    	int sz = 0;
    	while (*(arr + sz) != '\0')
    	{
    		sz++;
    	}
    	for (int i = 0; i 

    🍊strncmp函数

    有限制字符串比较函数

    
    🍒strncmp函数使用 
    strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
    
    #include

    #include

    int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

    我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
     
     🍭strncmp函数模拟实现 
    < num; i++)
    	{
    		if (*(arr + i) != *(arr2 + i))
    		{
    			return *(arr + i) - *(arr2 + i);
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    	char arr[] = "abcde";
    	char arr2[] = "bcde";
    	printf("%d\n", my_strncmp(arr, arr2, 3));
    	return 0;
    }
    #include
    #include
    
    int my_strncmp(char* arr, char* arr2, int num)
    {
    	for (int i = 0; i 

    👕strstr函数

    字符串查找函数。

    
    👚strstr函数使用 
    我们使用代码对strstr函数进行分析观察,代码如下: 
    
    #include

    #include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

    我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

    的地址,那么打印结果应该为fabcdeabc,运行结果如图。

     
     我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
    
    #include

    #include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

    子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

    [+++]

    ,我们通过运行结果图来进行分析,如下图。

     
     通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
    🎸strstr模拟实现 
    
    #include

    #include

    char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

    🍚 总结

    本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

       )
    File: /www/wwwroot/outofmemory.cn/tmp/route_read.php, Line: 126, InsideLink()
    File: /www/wwwroot/outofmemory.cn/tmp/index.inc.php, Line: 166, include(/www/wwwroot/outofmemory.cn/tmp/route_read.php)
    File: /www/wwwroot/outofmemory.cn/index.php, Line: 30, include(/www/wwwroot/outofmemory.cn/tmp/index.inc.php)
    字符串函数【C语言-2】_C_内存溢出

    字符串函数【C语言-2】

    字符串函数【C语言-2】,第1张

    🍠订阅专栏: 字符串函数

    🍅关注博主:翻斗花园第一代码手牛爷爷

    目录

     🍍前言

    🌽函数介绍

    🏡strncpy函数

    🍐 strncpy函数使用

    🍓strncpy函数模拟实现

    🍉strncat函数

    🍚 strncat函数使用

    🍎strncat函数模拟实现

    🍊strncmp函数

    🍒strncmp函数使用

     🍭strncmp函数模拟实现

    👕strstr函数

    👚strstr函数使用

    🎸strstr模拟实现

    🍚 总结


     

     🍍前言

    在第一篇中我们介绍了几种字符串函数,今天我们接上第一篇继续介绍字符串函数,对其功能进行模拟实现,注意事项进行说明标出。

    🌽函数介绍 🏡strncpy函数
    char * strncpy ( char * destination, const char * source, size_t num );

    有限制字符串拷贝函数

    •  拷贝num个字符从源字符串到目标空间
    • 如果源字符串长度小于num,则拷贝完源字符串后,在目标空间的后面追加  char * strncat ( char * destination, const char * source, size_t num );  直到num个。
    🍐 strncpy函数使用

    strncpy函数和strcpy函数非常类似,区别在于一个有限制一个没有限制,下面我们用代码来看strncpy的具体使用。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 2));
    	return 0;
    }

    我们从arr2数组中拷贝2个字符到arr数组中,然后打印观察结果,运行结果如图:

     我们知道arr2数组的大小为arr[5],当我们要从arr2数组中拷贝6个字符到arr数组中去,又会是怎么样的结果呢,我们还是用代码来观察。

    #include 
    #include 
    
    int main()
    {
    	char arr[] = "abcdefg";
    	char arr2[] = "****";
    	printf("%s\n", strncpy(arr, arr2, 6));
    	return 0;
    }

    运行结果如图:

     单靠运行结果图我们难以观察,我们再通过监视图观查,如下图:

     通过上面两个图我们可以看出,当源字符串长度小于num时,会在目标空间的后面继续补上

  • 目标空间必须足够大,能够存放下源字符串的内容。
  • ,直到num个。

    🍓strncpy函数模拟实现
    #include 
    #include 
    
    char* my_strncpy(char* arr, char* arr2, int num)
    {
    	int i = 0;
    	for (i = 0; i < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + i) = *(arr2 + i); } else { break; } } for (; i < num; i++) { *(arr + i) = '
    '; } return arr; } int main() { char arr[] = "abcdefg"; char arr2[] = "****"; printf("%s\n", my_strncpy(arr, arr2, 3)); return 0; }
     
    🍉strncat函数 
    

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

    有限制字符串追加函数
    •  在目标字符串的
    •  比较的是字符的大小,不是字符串的长度。
    • 位置出开始追加。在追加完毕时会主动补上
    • 函数有返回值,当返回值等于0时,表示两字符串相等,大于0时表示str1大于str2,小于0时表示str1小于str2。
    • 追加的最大长度为源字符串的长度加1,当num大于源字符串的长度时,追加的个数还是源字符串的长度加1。(加1是在因为有
    • const char * strstr ( const char * str1, const char * str2 ); char * strstr ( char * str1, const char * str2 );

  •  在一个字符串中查找另一个字符串,如果存在,返回查找到的字符串的首字符地址,如果不存在,返回空指针。
  • 🍚 strncat函数使用 当使用strncat函数开始追加时,源字符串会在目标字符串的 \0 位置出开始追加,追加完毕后主动补上

  • 如果查找到的子串存在多份,则返回第一次出现的字符串的首字符地址。
  • ,下面我们用代码观察strncat函数的具体实现。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 2)); return 0; }

    我们将arr2数组中的2个字符追加到arr数组中,然后打印字符串,运行结果图如下:

    我们在通过监视图观察

    f

    的情况。 如下图:

     通过监视图我们可以观察到,在追加2个字符后会补上一个

    fab
    。如果当num大于源字符串的长度时,又会是什么情况呢?我们继续通过代码观察,代码如下。 
    #include 
    #include 
    int main() { char arr[20] = "abcde\0iiiiiiiiiiii"; char arr2[] = "***"; printf("%s\n", strncat(arr, arr2, 6)); return 0; }

    我们将arr2数组追加6个字符到arr数组中,我们知道arr2数组的大小为4,num大于arr2数组的长度,运行后我们观察结果,运行结果如图。

     我们在辅以监视图观察。

     通过观察两个图我们可以知道,strncat函数追加的最大长度为源字符串的长度在加上一个

    fabcdefabc
    。还有一点我们需要特别注意的是,我们必须先保证目标空间的大小足以放下源字符串。 
    🍎strncat函数模拟实现 
    #include < num; i++)
    	{
    		if (*(arr2 + i) != '
    ') { *(arr + sz) = *(arr2 + i); sz++; } else { break; } } *(arr + sz) = '
    '; return arr; } int main() { char arr[20] = "abcdef"; char arr2[] = "****"; printf("%s\n", my_strncat(arr, arr2, 3)); return 0; } #include
    
    char* my_strncat(char* arr, char* arr2, int num)
    {
    	int sz = 0;
    	while (*(arr + sz) != '\0')
    	{
    		sz++;
    	}
    	for (int i = 0; i 

    🍊strncmp函数

    有限制字符串比较函数

    
    🍒strncmp函数使用 
    strncmp函数与strncmp函数十分相似,都是比较字符的大小,都有返回值。下面我们通过代码来观察,代码如下。 
    
    #include

    #include

    int main() { char arr[] = "abcdef"; char arr2[] = "bcde"; printf("%d\n", strncmp(arr, arr2, 2)); return 0; }

    我们通过strncmp函数比较arr数组和arr2数组的前2个字符,并且打印返回值,运行结果如下。 
     
     🍭strncmp函数模拟实现 
    < num; i++)
    	{
    		if (*(arr + i) != *(arr2 + i))
    		{
    			return *(arr + i) - *(arr2 + i);
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    	char arr[] = "abcde";
    	char arr2[] = "bcde";
    	printf("%d\n", my_strncmp(arr, arr2, 3));
    	return 0;
    }
    #include
    #include
    
    int my_strncmp(char* arr, char* arr2, int num)
    {
    	for (int i = 0; i 

    👕strstr函数

    字符串查找函数。

    
    👚strstr函数使用 
    我们使用代码对strstr函数进行分析观察,代码如下: 
    
    #include

    #include int main() { char arr[] = "abcdfabcdeabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; }

    我们用strstr函数在arr数组字符串中查找arr2数组中的字符串,如果查找到返回arr数组中字符

    的地址,那么打印结果应该为fabcdeabc,运行结果如图。

     
     我们可以知道strstr函数查找到返回确实是字符串首字符的地址,而当字符串中查找到多份子串时,有是什么结果呢?我们可以通过下面的代码进行观察。 
    
    #include

    #include int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "fab"; printf("%s\n", strstr(arr, arr2)); return 0; } 上面代码我们知道arr数组中存在两份

    子串,如果返回的是第一次子串的地址的话,那么打印出来的结果就应该是

    ,我们通过运行结果图来进行分析,如下图。

     
     通过上面的代码我们知道,如果在被查找的字符串中存在多份字串时,返回的还是第一次出现的字串的地址。 
    🎸strstr模拟实现 
    
    #include

    #include

    char* my_strstr(char* arr, char* arr2) { char* p = arr; char* q = arr2; int sz = 0; int i = 0; while (*p != '\0' && *q != '\0') { if (*p == *q) { p++; q++; } else { p = arr + 1; arr = p; q = arr2; } } if (*p == '\0' && *q != '\0') { return NULL; } else { return arr; } } int main() { char arr[] = "abcdfabcdefabc"; char arr2[] = "efab"; printf("%s\n", my_strstr(arr, arr2)); return 0; }

    🍚 总结

    本章介绍了strncpy函数,strncat函数,strncmp函数,strstr函数的用法以及模拟实现,接下来也会继续更新字符串函数,关注博主来个一键三连呗,你的支持是我更新的动力。

       

    欢迎分享,转载请注明来源:内存溢出

    原文地址: https://outofmemory.cn/langs/3001810.html

    (0)
    打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
    上一篇 2022-09-27
    下一篇 2022-09-27

    发表评论

    登录后才能评论

    评论列表(0条)

    保存