片头
在上一篇中,我们介绍了字符串函数。在这一篇章中，我们将继续学习字符串函数，准备好了吗？开始咯！
1.strncpy函数
1.1 strncpy函数的用法
strncpy是C语言中的一个字符串处理函数，它用于将一个字符串的一部分内容复制到另一个字符串中。
其函数原型为:
其中，dest是目标字符串的指针，src是源字符串的指针，n是要复制的字节数。
该函数将源字符串src的前n个字符复制到目标字符串dest中，并返回目标字符串的指针。
需要注意的是，如果源字符串 src 的长度小于n，则复制完后目标字符串dest剩余的字节将填充为'\0'，确保目标字符串以'\0'结尾。如果源字符串src的长度大于或等于n，则目标字符串dest可能不以'\0'结尾。
这个函数常用于处理字符串截断或复制的情况，例如从一个字符串中复制一定长度的子串到另一个字符串中。
1.2 使用strncpy函数
当源字符串 src 的长度大于 n
#include<stdio.h>
#include<string.h>
int main() {
char dest[] = "##############";
char src[20] = "little pig"; //从src中拷贝6个字符到dest中
strncpy(dest, src, 6);
printf("目标字符串为: %s\n", dest);
return 0;
}运行的结果为:
当 src 字符串长度小于 n
#include<stdio.h>
#include<stdlib.h>
int main() {
char dest[100] = "##############";
char src[12] = "little pig";
strncpy(dest, src, 20); //将src数组的前20个字符拷贝到dest中去
printf("目标字符串为: %s\n", dest);
return 0;
}运行的结果为:
1.3 strncpy的模拟实现
思路: 1. 拷贝num个字符从源字符串到目标空间
2. 如果源字符串的长度小于num,则拷贝完源字符串之后,在目标字符串的后面追加'\0',直到num个
void my_strncpy(char arr1[], char arr2[], int num) {
assert(arr1 && arr2);
char* s1 = arr1;
char* s2 = arr2;
int len = strlen(arr2);
if (len < num) {
//如果源字符串的长度小于num,
//则拷贝完源字符串之后,在目标的后面追加\0,直到num个
while (num--) {
if (*s2 != '\0') {
*s1 = *s2;
s1++;
s2++;
}
else {
*s1 = '\0';
}
}
}
else {
//len > num ,根据num来拷贝
while (num--) {
*s1 = *s2;
s1++;
s2++;
}
}
}
int main(){
//strncpy函数
char arr1[100] = "#########";
char arr2[12] = "hello world";
my_strncpy(arr1, arr2, 5); //将arr2中5个字符拷贝到arr1中
printf("arr1的字符串为: %s\n", arr1);
return 0;
}打印的结果为:
还有一种方式可以实现:
void my_strncpy1(char arr1[], char arr2[],int num) {
int i = 0;
//下标i从0开始
//当arr2[i]不等于'\0' 并且 下标 i < num时, 进入循环
for (i = 0; arr2[i] != '\0' && i < num; i++) {
//将arr2对应下标的元素赋值给arr1
arr1[i] = arr2[i];
}
//src 中的'\0'有没有被拷贝
if (i < num) {
arr1[i] = '\0';
}
}
int main(){
char arr1[100] = "#######";
char arr2[12] = "hello world";
my_strcpy1(arr1,arr2,20); //将arr2中前20个字符拷贝到arr1中
printf("arr1的字符串为: %s\n",arr1);
return 0;
}执行结果为:
还有另外一种解法,不过,都大同小异啦,思路差不多,上代码!
char* my_strncpy2(char arr1[], char arr2[], int num) {
//断言 arr1 和 arr2 不是空指针,以确保它们是有效的地址
assert(arr1 && arr2);
//保存arr1的原始地址,以便稍后返回
char* ret = arr1;
char* s1 = arr1;
char* s2 = arr2;
//循环复制字符,直到遇到源字符串的结束符'\0',或者复制了num个字符
while (*s2 && num) {
*s1 = *s2;
s1++;
s2++;
num--; //每复制完一个字符,num自减一次
}
//如果num不为0,说明还有剩余的空间需要填充 NULL('\0')终止符
if (num != 0) {
while (num) {
*s1 = '\0';
s1++;
num--;
}
}
return ret;
}
int main(){
char arr1[100] = "AAAAAAAAAAA";
char arr2[] = "bbq";
char* S = my_strncpy2(arr1,arr2,20);
printf("arr1中的字符串为: %s\n",arr1);
return 0;
}执行结果为:
2. strncat函数
2.1 strncat函数的用法
函数名strncat是"string concatenate"的缩写,是C语言中的字符串连接函数。它的作用是将一个字符串的前n个字符连接到另一个字符串的末尾。
函数的原型如下：
其中，destination是目标字符串,source是要连接的字符串,n是要连接的字符数。
函数的执行过程是将source字符串的前n个字符复制到destination字符串的末尾,并在复制完成后在destination字符串的末尾添加一个字符串结束符'\0'。如果source字符串的长度小于n,则复制整个source字符串。
函数的返回值是指向目标字符串的指针，即destination字符串的地址。
需要注意的是，strncat函数没有自动分配额外的空间来容纳连接后的字符串,因此在使用之前需要确保destination字符串有足够的空间来容纳连接后的结果。否则，可能会导致内存越界错误。
2.2 使用strncat函数
当src的字符串长度大于 n
#include<stdio.h>
#include<stdlib.h>
int main() {
char str1[20] = "happy";
char str2[20] = "happy day";
strncat(str1, str2, 5); //将str2中的前5个字符拷贝到str1中
printf("str1字符串的结果为: %s\n", str1);
return 0;
}执行结果为:
当src的字符串长度小于等于 n
#include<stdio.h>
#include<stdlib.h>
int main() {
char str1[20] = "happy";
char str2[20] = "happy day";
strncat(str1, str2, 15); //将str2字符串的前15个字符拷贝到str1中
printf("str1字符串的结果为: %s\n", str1);
return 0;
}执行结果为:
2.3 strncat的模拟实现
思路: 循环遍历找到dest字符串数组的末尾,将src的前n个字符复制到dest字符串数组的后面,并更新dest字符串的长度
代码如下:
char* my_strncat(char arr1[], char arr2[],int num) {
assert(arr1 && arr2);
char* ret = arr1; //保存arr1的原始地址,以便稍后返回
char* s1 = arr1;
char* s2 = arr2;
int len = strlen(arr2); //定义变量len,用来记录arr2的长度
while (*s1 != '\0') { //循环遍历找到arr1字符串的末尾
s1++;
}
//s1所指向的位置 就是\0的位置
//source字符串的前n个字符复制到destination字符串的末尾,
//并在复制完成后在destination字符串的末尾添加一个字符串结束符'\0'
//如果source字符串的长度小于n,则复制整个source字符串
if (len > num) {
while (num--) {
*s1 = *s2;
s1++;
s2++;
}
*s1 = '\0';
}
else {
// len < num, 复制整个source字符串
while (num--) {
if (*s2 != '\0') {
*s1 = *s2;
s1++;
s2++;
}
else {
*s1 = '\0';
}
}
}
return ret;
}
int main(){
char arr1[100] = "ABCD";
char arr2[] = "abcd";
my_strncat(arr1, arr2, 20); //将arr2的前20个字符拷贝到arr1中
printf("arr1字符串数组为: %s\n", arr1);
return 0;
}
执行结果如下:
关于这个strncat函数,还有另外一种解法:
char* my_strncat1(char* dest, char* src, int n) {
//将dest首地址保存在temp中
char* temp = dest;
//1. 找到dest的'\0'位置
while (*dest != '\0') {
dest++;
}
//dest所指向的位置 就是\0的位置
int i = 0;
//2. 开始拷贝
for (i = 0; i < n && src[i] != '\0'; i++) {
dest[i] = src[i];
}
//如果src字符串的长度小于n,则拷贝完src数组后,在后面补'\0'
if (i < n) {
dest[i] = '\0';
}
return temp;
}
int main(){
char arr1[100] = "ABCDEF";
char arr2[] = "abcd";
my_strncat1(arr1, arr2, 2); //将arr2字符串数组的前2个元素拷贝到arr1中
printf("arr1字符串为: %s\n", arr1);
return 0;
}执行结果为:
没看够? 还有一种方式可以实现哟!
代码如下:
char* my_strncat2(char* dest, char* src, int n) {
char* ret = dest; //将dest首地址存储在ret中
assert(dest && src);//保证dest、src非空
while (*dest != '\0')
{
dest++; //找到dest结尾的'\0'
}
while (n && (*dest++ = *src++)) //把src里的字符一个个放入dest后
{
n--; //跳出循环的条件
}
if (n == 0) {
*dest = '\0'; //如果n<src
}
return ret; //返回dest字符串的起始地址
}
int main(){
char arr1[100] = "ABCD";
char arr2[] = "abcdefgh";
my_strncat2(arr1, arr2, 6); //将arr2字符串数组的前6个字符拷贝到arr1中
printf("arr1字符串数组为: %s\n", arr1);
return 0;
}执行结果为:
3. strncmp函数
3.1 strncmp函数的用法
strncmp是C语言中的一个字符串比较函数。它用于比较两个字符串的前n个字符是否相等。
函数原型如下：
其中，参数的含义如下：
- str1: 要比较的第一个字符串
- str2: 要比较的第二个字符串
- n : 要比较的字符数
函数返回值:
- 若前n个字符相等,则返回0
- 若 str1 小于 str2, 则返回负值
- 若str1 大于 str2, 则返回正值
注意:
- 如果要比较的字符数n大于两个字符串的长度,则比较的字符数会被限制为两个字符串的最小长度。
3.2 strncmp的使用
#include<stdio.h>
#include<string.h>
int main() {
char arr1[30] = "abcdefg";
char arr2[30] = "abcdeee";
char arr3[30] = "abcdfgh";
int ret1 = strncmp(arr1, arr2, 4); //比较arr1和arr2的第4个字符
int ret2 = strncmp(arr1, arr2, 6); //比较arr1和arr2的第6个字符
int ret3 = strncmp(arr2, arr3, 5); //比较arr2和arr3的第5个字符
int ret4 = strncmp(arr1, arr3, 7); //比较arr1和arr3的第7个字符
printf("ret1 = %d\n", ret1);
printf("ret2 = %d\n", ret2);
printf("ret3 = %d\n", ret3);
printf("ret4 = %d\n", ret4);
return 0;
}运行结果为:
3.3 strncmp的模拟实现
思路: 逐个比较两个字符串的前n个字符的ASCII码值,直到遇到不同的字符、遇到空字符或比较完n个字符为止,根据比较结果返回相应的整数。
代码如下:
int my_strncmp(char arr1[], char arr2[], int num) {
char* s1 = arr1; //指针s1指向arr1
char* s2 = arr2; //指针s2指向arr2
while (num--) { //比较num次
if (*s1 == *s2) { //如果s1指向的元素和s2指向的元素相同
s1++; //s1指针向后移动一个字符
s2++; //s2指针向后移动一个字符
}
else {
return *s1 - *s2;
//如果s1指向的元素和s2指向的元素不相同,则返回ASCII码的差值
}
}
return 0; //如果num的次数用完,
//两个指针指向的元素相同,则返回0
}
int main(){
char arr1[] = "abcdefgA";
char arr2[] = "abcdefga";
int ret2 = my_strncmp(arr1, arr2, 8); //从前往后比较8个字符
printf("%d\n", ret2);
return 0;
}执行结果为:
为啥是-32呢? 因为'A'的ASCII码值为 65, 'a'的ASCII码值为 97, 65 - 97 = -32
关于这个函数,还有另外一种方法:
int my_strncmp1(char arr1[], char arr2[], int num) {
assert(arr1 && arr2);
char* s1 = arr1;
char* s2 = arr2;
//如果n为0,说明不需要比较任何字符,直接返回0
//表示两个字符串的前0个字符是相同的
if (num == 0) {
return 0;
}
//循环条件中,*s1 == *s2 确保两个字符相同
// *s1 确保 s1 没有到达字符串结束符
// --num 确保已经比较了 num 个字符或 num 已经减到0
while (*s1 == *s2 && *s1 && *s2 && --num)
{
//如果两个字符相同且没有到达字符串的结束符,继续比较下一个字符
s1++;
s2++;
}
//返回的是两个字符的ASCII码差值
return *s1 - *s2;
}
int main(){
char arr1[] = "abcdefgA";
char arr2[] = "abcdefga";
int ret3 = my_strncmp1(arr1, arr2, 7); //从前往后比较7个字符
printf("%d\n", ret3);
return 0;
}执行结果:
为啥结果为0呢? 因为两个字符串的前7个字符的ASCII码值都相同,因此,结果为0。
还有另外一种思路,大致都差不多,我们一起来看看
int my_strncmp2(char arr1[], char arr2[], int num) {
int i = 0; //下标i从0开始,比较两个字符串
char* s1 = arr1; //指针s1指向arr1
char* s2 = arr2; //指针s2指向arr2
//当 *s1 并且 *s2 不为'\0'
//并且满足两个指针指向的元素相同,
//还要满足下标i<要拷贝的长度num
while (*s1 && *s2 && *s1 == *s2 && i < num)
{
s1++;
s2++;
i++; //如果字符相同,两个指针都往后走一步,i自增一次
}
if (i == num) { //如果下标i已经等于num,说明从下标从 0 ~ num-1 的元素都相同
return 0; //前n个字符相等,返回0
}
else {
return *s1 - *s2;
//如果i<num,说明遍历过程中,中间有字符不相同,那么返回两个字符ASCII码值相减的结果
}
}
int main(){
char str1[] = "abcd";
char str2[] = "abcD";
int ret = my_strncmp2(str1,str2,4); //从头到尾比较arr1和arr2的前4个字符
printf("%d\n",ret);
return 0;
}。执行结果为:
'd'的ASCII码值为100,'D'的ASCII码值为68, ASCII码值相减的结果为: 100 - 68 = 32
4. strtok函数
4.1 strtok函数的用法
strtok函数是C语言中的字符串分割函数,用于将一个字符串按照指定的分隔符进行分割并返回分割后的子字符串。该函数可以帮助我们遍历一个字符串中的各个子串。
函数原型如下：
其中,参数的意义如下:
str: 在第一次调用时,str是传入需要被切割字符串的首地址; 在后续调用时,str应置为NULL,以便strtok函数能够在之前的位置基础上继续查找下一个标记。
sep: 这是一个字符串,它定义了用作分隔符的字符集合。字符串中的每个字符都会被当作一个分隔符。
工作原理：
1. strtok函数在str字符串中查找由sep字符串定义的分隔符。当找到分隔符时，strtok函数会将其替换为'\0'字符,从而结束当前子串。
2. strtok函数返回指向当前找到的子串的指针。这个子串是从str开始,到当前找到的分隔符(现在已经替换为'\0')结束的部分
3. 在第一次调用之后,strtok会保存其在str中的位置,以便后续调用时能够继续查找下一个子串。因此，在后续调用中，需要将str参数设置为NULL。
4. 如果字符串中不存在更多的分隔符，strtok函数将返回NULL指针。
请注意：strtok函数会破坏被分解字符串的完整性。调用strtok函数后,原字符串str的内容会被修改,因为它会将分隔符替换为'\0'。因此，通常建议对原始字符串进行拷贝，并在拷贝的字符串上使用strtok,以避免修改原始数据。
2. strtok函数的使用
#include<stdio.h>
#include<string.h>
int main() {
char arr[] = "111.222.333.444";
char* sep = "."; //分隔符为"."
char* str = NULL;
for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep)) {
printf("%s\n", str);
}
return 0;
}执行结果为:
我们一起来分析分析:
111.222.333.444
使用strtok函数后,它会在在找到分隔符的位置后,将那个位置的字符设置为'\0' 来结束当前的标记。
然后从上一次标记的地方开始找下一个标记,直至结束。
简而言之，就是“strtok函数会把目标字符串中间的符号作为分隔符,将目标字符串分为几个子串”。
5. strerror函数
5.1 strerror函数的用法
strerror函数可以把参数部分错误码对应的错误信息的字符串地址返回来。
函数原型如下：
在不同的系统和C语言标准库的实现中都规定了一些错误码,一般放在errno.h 这个头文件中说明的,C语言程序启动的时候就会使用一个全局变量errno来记录程序的当前错误码,只不过程序启动的时候errno是0,表示没有错误,当我们在使用标准库中的函数的时候发生了某种错误,就会将对应的错误码,存放在errno中,而一个错误码的数字是整数，很难理解是什么意思,所以每一个错误码都是有对应的错误信息的。strerror函数就可以将错误对应的错误信息字符串的地址返回。
5.2 strerror的使用
#include<stdio.h>
#include<string.h>
int main() {
int i = 0;
for (i = 0; i < 10; i++) {
printf("%s\n", strerror(i));
}
return 0;
}
输出的结果为:
- No error (没有错误。这通常表示操作成功，没有发生任何错误)
- Operation not permitted（操作不允许。这表明尝试进行的操作由于权限不足或其他限制而未能执行）
- No such file or directory（没有这样的文件或目录。这通常意味着程序试图访问一个不存在的文件或目录）
- No such process（没有这样的进程。这通常发生在尝试运行或管理一个不存在的进程时）
- Interrupted function call（被中断的函数调用。这可能是由于某些外部因素（如用户中断）导致正在执行的函数被突然终止）
- Input/output error（输入/输出错误。这通常发生在读取或写入文件或其他设备时，可能是由于设备故障、文件系统损坏或其他问题导致的）
- No such device or address（没有这样的设备或地址。这通常表示程序试图访问一个不存在的设备或网络地址）
- Arg list too long（参数列表过长。这通常发生在命令行参数超过系统限制时）
- Exec format error（执行格式错误。这通常意味着尝试执行的程序或文件格式不正确或不被支持）
- Bad file descriptor（错误的文件描述符。这通常表明程序尝试使用了一个无效或未正确初始化的文件描述符）
片尾
字符串函数的内容就先讲到这里，下一篇文章我们将会学习内存操作函数
看到这里的友友们，感谢你们的支持，
求个点赞收藏加关注！！！
十分感谢! ! !
