C语言——字符函数与字符串函数

迷迭所归处

发布于 2024-11-19 17:01:28

7100

代码可运行

文章被收录于专栏：动态规划动态规划

运行总次数：0

代码可运行

1.字符分类函数

C语言中有一系列的函数是专门做字符分类的，也就是一个字符是属于什么类型的字符的，而这些函数的使用的需要包含一个头文件<ctype.h>

这些函数的使用方法非常类似，就拿islower函数来举例

int islower(int c);

islower是用来判断参数部分的c是否是小写字母的

如果返回值是小写字母就返回非0的整数，如果不是就返回0

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

int main()
{
	char arr[] = "Hello WErd";
	int i = 0;
	while (arr[i]!='\0')
	{
		if (islower(arr[i]))
		{
			arr[i] -= 32;
		}
		i++;
	}
	printf("%s\n", arr);
	return 0;
}

这段代码用来进行小写转大写，如果要大写转小写只需把-32改为+32

2.字符转换函数

c语言中提供了2个字符转换函数:

//将参数传进去的大写字母转小写字母
int tolower(int c);
//将参数传进去的小写字母转大写字母
int toupper(int c);

tolower:大转小 | toupper:小转大

这两个函数是直接进行转换

int main()
{
	char arr[] = "Hello WErd";
	int i = 0;
	while (arr[i] != '\0')
	{
		if (islower(arr[i]))
		{
			//大写转小写
			arr[i] = tolower(arr[i]);
			//小写转大写
			//arr[i] = toupper(arr[i]);
		}
		i++;
	}
	printf("%s\n", arr);
	return 0;
}

3.strlen的使用和模拟实现

strlen：求字符串\0之前的长度

1.字符串以\0'作为结束标志，strlen函数返回的是在字符串中'\0'前面出现的字符个数（不包含'\0')

2.参数指向的字符串必须要以 '\0' 结束

3.strlen函数的返回值为size_t，是无符号的，并且很容易出错

如：

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

int main()
{
	const char* str1 = "abcdef";
	const char* str2 = "bbb";
	//   size_t              size_t
	//          3    -          6
	if (strlen(str2) - strlen(str1) > 0)
	{
		printf("str2>str1\n");
	}
	else
	{
		printf("srt1>str2\n");
	}
	return 0;
}

上面这段代码的答案并不是”<=“，而是”>“，因为strlen的返回值是size_t，size_t是无符号，一个无符号的值减去另一个无符号的值的结果也为无符号的值

if ((int)strlen(str2) - (int)strlen(str1) > 0)

但是给其强制转换一下类型就可以正常加减

三种模拟实现

1.计数器实现

int my_strlen(const char * str)
{
	int count = 0;
	assert(str);
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}

int main()
{
	char arr[] = "abcdefg";
	size_t len = my_strlen(arr);
	printf("%zd\n", len);
	return 0;
}

2.递归实现

不创建临时变量计数器

int my_strlen(const char* str)
{
	assert(str);
	if (*str == '\0')

		return 0;
	else
	return 1+strlen(str+1);//str+1是下一个字符的地址
}

int main()
{
	char arr[] = "abcdefg";
	size_t len = my_strlen(arr);
	printf("%zd\n", len);
	return 0;
}

判断*str是否为\0，如果是就停止，如果不是就继续++

3.指针-指针实现

int my_strlen( char* str)
{
	assert(str);
	char* p = str;
	while (*p!='\0')
	{
		p++;
	}
	return p - str;
}

int main()
{
	char arr[] = "abcdefg";
	size_t len = my_strlen(arr);
	printf("%zd\n", len);
	return 0;
}

p2的地址-p1的地址得到中间的个数

4.长度不受限制的字符串函数

4.1 ：strcpy的使用和模拟实现

strcpy:用来拷贝字符串 dest :目的地 | source :源头把源头的数据拷贝到目的地的空间去

1.源字符串必须以 '\0' 结束

2.strcpy会将源字符串中的 '\0' 也拷贝到目标空间

3.目标空间必须足够大，以确保能存放源字符串

4.目标空间必须可以修改

如：

int main()
{
	char arr1[] = "hello word";
	char arr2[20] = { 0 };
	strcpy(arr2, arr1);
	printf("%s\n", arr2);//（dest,source）
	return 0;
}

模拟实现：

初始版本

void my_strcpy(char* dest,const char* src)
{
    assert(src!=NULL);
    assert(dest!=NULL);
//拷贝\0之前的内容
   while(src!=\0)
    {
       *dest=*src;
        dest++;
        src++; 
    }
//拷贝\0
    *dest=*src;
}

int main()
{
	char arr1[] = "hello word";
	char arr2[20] = { 0 };
	my_strcpy(arr2, arr1);
	printf("%s\n", arr2);//（dest,source）
	return 0;
}

优化版本

void my_strcpy(char* dest,const char* src)
{
    assert(src!=NULL);
    assert(dest!=NULL);
    char* ret = dest;
//拷贝\0之前的内容
   while(*dest++ = *src++)
    {
       ;
    }
    return ret;
}

int main()
{
	char arr1[] = "hello word";
	char arr2[20] = { 0 };
	char* ret=my_strcpy(arr2, arr1);
	printf("%s\n", arr2);//（dest,source）
	return 0;
}

4.2 strcat的使用和模拟实现

strcat:追加一个source指向的字符串到目标空间（dest）里去

1.源字符串必须以 '\0' 结束

2.目标字符串在必须也得有\0，否则没办法知道从哪里开始追加

3.目标空间必须有足够的大，能容纳下源字符串的内容

4.目标空间必须可修改

如：

int main()
{
	char arr1[20] = "hello";
	char arr2[] = "word";
	strcat("%s\n", arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

步骤：1.找到目标空间的\0

2.拷贝数据

模拟实现：

//函数返回的是目标空间的起始地址，返回类型为char*

char* my_strcat(char* dest, char* src)
{
	assert(dest && src);
	char* ret = dest;
	//找到起始空间的\0
	while (dest != '\0')
	
		dest++;
	
	//拷贝
	while (*dest++ = *src++)
	
		;//;号是一个空语句
	
	return ret;
}

int main()
{
	char arr1[20] = "hello";
	char arr2[] = "word";
	//模拟
	my_strcat("%s\n", arr1, arr2);
	printf("%s\n", arr1);
	//使用
	//char* s = my_strcat("%s\n", arr1, arr2);
	//printf("%s\n",s);
	return 0;
}

一个字符串自己给自己追加如何呢？

1.会越界访问

2.会死循环

4.3:strcmp的使用和模拟实现

strcmp:用来对两个字符串进行比较大小返回值为int 类型

1.当第一个字符串大于第二个字符串的时候则返回>0的值

2.当第一个字符串等于第二个字符串的时候则返回0的值

3.当第一个字符串小于第二个字符串的时候则返回<0的值

对比两个字符串的字符的大小用ASCII值大小来比较

模拟实现：

int* my_strcmp(const char* str1, const char* str2)
{
	int ret = 0;
	assert(*str1 && *str2);
	while (*str1==*str2)
	{
		if (*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
	}
	//1.
	/*if (*str1 >*str2 )
	{
		return 1;
	}
	else
	{
		return -1;
	}*/
	//2.
	return *str1 - *str2;
}

int main()
{
	char arr1[20] = "abcd";
	char arr2[20] = "abdhtf";
	int ret = my_strcmp(arr1, arr2);
	return 0;
}

长度受限制的字符串函数

5.1 strncpy函数的使用(拷贝)

与strcpy相比，strncpy的参数多了一个num

num：从source中最多拷贝几个

1.拷贝num个字符从源字符串到目标空间

2.如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加\0，直到num个

int main()
{
	char arr1[20] = "abcd";
	char arr2[20] = "xxxxxxxxxxxxxxxx";
	int ret = strncpy(arr2, arr1,3);
    //如果拷贝source的的字符串小于指定拷贝的num，那么后面就补\0
    //int ret = strncpy(arr2, arr1,8);
    printf("%s\n",arr2);
	return 0;
}

5.2 strncat函数的使用（追加）

与strcat相比，strncat的参数多了一个num

num：从source中最多追加几个

1.将source指向字符串的前num个字符追加到dest指向的字符串未尾，再追加一个\0字符

2.如果source指向的字符串的长度小于num的时候，只会将字符串中\0的内容追加到dest指向的字符串末尾

int main()
{
	char arr1[20] = "abcd";
	char arr2[20] = "xx\0xxxxxxxxxxxxxx";
	strncat(arr2, arr1,3);
    printf("%s\n",arr2);
	return 0;
}

如果中间插入一个\0的话，就会从第一个\0开始追加

5.3 strncmp函数的使用(比较)

与strcmp相比，strncmp的参数多了一个num

num：从source中最多比较几个

比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完

1.当第一个字符串大于第二个字符串的时候则返回>0的值

2.当第一个字符串等于第二个字符串的时候则返回0的值

3.当第一个字符串小于第二个字符串的时候则返回<0的值

对比两个字符串的字符的大小用ASCII值大小来比较

int main()
{
	char arr1[20] = "abcd";
	char arr2[20] = "abcfhy";
	int ret = strncmp(arr1, arr2, 6);
	printf("%d\n", ret);
	return 0;
}

补充一下

在c语言中，长度不受限制的字符串函数相对来说是不安全的，长度受限制的字符串函数相对来说是安全的

6.字符串查找

6.1 strstr函数的使用和模拟实现

strstr：在一个字符串中查找另一个字符串

1.函数返回字符串str2在字符串str1中第一次出现的位置，返回从第一次出现位置一直到后面

2.字符串的比较匹配不包含\0，以\0作为结束标志

如：

int main()
{
	char arr1[] = "hello word";
	const char arr2[] = "llo";
	//或者这种：const char* p = "llo";
	char* ret = strstr(arr1,arr2);
	if (ret != NULL)
	{
		printf("%s\n", ret);
	}
	else
	{
		printf("找不到\n");
	}
	return 0;
}

模拟实现：

这种情况需要有一个指针变量来记录开始匹配的位置

这种情况可能存在多次匹配，需要有2个指针变量来记录起始位置

字符串找完了也没找到

char* my_strstr(const char* str1,const char* str2)
{
	const char* s1 = NULL;
	const char* s2 = NULL;
	const char* cur = str1;

	while (*cur)
	{
		s1 = cur;
		s2 = str2;
		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		//如果*s2为\0，则说明子字符串已经全部匹配完成
		if (*s2 == '\0')
		{
			return cur;
		}
		cur++;
	}
	//当*cur为\0时，则返回NULL
	return NULL;
}

int main()
{
	char arr1[] = "abcdefgbcdkhu";
	const char arr2[] = "bcd";
	char* ret = my_strstr(arr1,arr2);
	if (ret != NULL)
	{
		printf("%s\n", ret);
	}
	else
	{
		printf("找不到\n");
	}
	
	return 0;
}

6.2 strtok函数的使用

strtok:用于将一个字符串按照指定的分隔符进行分割，从而得到想要的子字符串

1.sep参数是个字符串，定义了用作分隔符的字符集合

2.第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

3.strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注： strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改）

4.strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置

5.strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记

6.如果字符串中不存在更多的标记，则返回 NULL 指针

#include<stdio.h>
#include<string.h>
int main()
{
	char str[] = "kiana@jjwdjtmkadqyn.bh3";  //指定字符串
	char arr[30];
	strcpy(arr, str);     //拷贝一份临时的指定字符串,以避免改变str
	char* p = "@.";       //指定的分隔符(标记)
	char* tmp = strtok(arr, p);  //使用一次strtok,因其返回的是一个指针,所以用字符指针接收
	printf("%s\n", tmp);    //会打印出什么呢?
	return 0;
}

打印结果为：

kiana

因为strtok函数找到str中的下一个标记，并将该标记用\0结尾，然后返回一个指向该标记的指针

#include <stdio.h>
 int main()
 {
     char *p = "kiana@jjwdjtmkadqyn.bh3";
     const char* sep = ".@";
     char arr[30];
     char *str = NULL;
     strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
     for(str=strtok(arr, sep); str != NULL; str=strtok(NULL, sep))
       {
         printf("%s\n", str);
       }
 }

其中分隔符' . '和' @ '不需要注重顺序，但是要写齐