字符串函数（C语言详解）

1.字符串简介

字符串是一串连续的且以\0结尾的字符

char arr[]="zhangsan";//将字符串存到数组里面
char*a="lisi";//常量字符串
char arr1[]={'z','h','a','n','g'};//字符数组

注意：

1.以第一种形式初始化字符串时，计算机会自动在字符串末尾加上\0，所以在给数组申请内存空间时，需要多申请一个字节的内存来存放\0

2.第二种形式是常量字符串，是不可以被修改的

3.第三种形式是字符数组，末尾没有\0,输出时需要一个字符一个字符的输出，如果想要像字符串一样一次输出，可以在最后一个字符末尾手动加上一个\0（在确保内存空间足够的情况下），然后用%s打印

4.一个字符占用一个字节的内存空间

5.字符串也可以是中文，一个中文汉字占两个字节（GBK编码）

2.字符串函数

2.1字符串函数的头文件

#include

2.2 strlen()函数

2.2.1strlen函数的原型(计算字符串长度)

size_t strlen ( const char * str );

strlen函数的形参是一个char类型的地址，因为我们需要防止字符串的内容被修改，所以加上

const防止内容被修饰，返回值是size_t类型，也就是无符号整形，因为字符串的个数不可能为负数

2.2.2举例说明

#include
int main()
{
	char arr[] = "1234567890";
	size_t len = strlen(arr);
	printf("%zd", len);
	return 0;
}

因为strlen的返回值是size_t,所以我们用size_t len来接收返回值，当然也可以用int来接收，结果也是正确的

2.2.3模拟实现strlen（）函数

模拟1（计数）

size_t my_strlen(const char* str)
{
    assert(str);//断言str是否为空指针
	size_t count = 0;
	while (*str)//因为\0的的ASCLL码为0，所以当str指向\0时，不进行循环
	{
		count++;//如果str不指向\0，那么count++，统计字符个数
		str++;//统计完一个字符，向后走一个字节
    }
	return count;
}

模拟2（递归）

size_t my_strlen1(const char* str)
{
	assert(str);
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}

模拟3（指针减指针）

size_t my_strlen(const char* str)
{
	assert(str);
	char* p = str;
	while (*str)
	{
		str++;
	}
	return str - p;
}

2.3 strcpy（）函数

2.3.1strcpy函数的原型（字符串拷贝）

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

char*destination用来接收拷贝的目标地址，const char *source用来接收源字符串地址

2.3.2 举例说明

strcpy函数在使用时，会将目标空间内容覆盖

注意：1.源字符串必须以\0结尾

           2.strcpy会将\0拷贝到目标空间

           3.确保目标空间足够大，能放下源字符串

           4.确保目标空间可修改

2.3.3模拟实现strcpy（）函数

char* my_strcpy(char* dest, const char* src)
{
	char* ret = dest;//记录一下起始位置的地址
	assert(dest != NULL);
	assert(src != NULL);
	while (*dest++=*src++)//挨个赋值，如果遇到\0，将\0赋值后，条件语句为假，就退出循环
	{
		;
	}
	return ret;
}

2.4 strcat（）函数

2.4.1 strcat函数的原型（字符串连接）

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

2.4.2 举例说明

int main()
{
	char arr[100] = "1234567890";
	char brr[] = "888888";
	strcat(arr,brr);
	printf("%s", arr);;
	return 0;
}

注意：1.源字符串必须以\0结尾

           2.目标字符串必须要与\0,否则没办法知道从哪里开始追加

           3.确保目标空间足够大，能放下目标字符串和源字符串

           4.确保目标空间可修改

2.4.3模拟实现strcat（）函数

char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	while (*dest)
	{
		dest++;//循环找到\0的位置
	}
	while (*dest++ = *src++)//从\0的位置开始追加
	{
		;
	}
	return ret;
}

2.5 strcmp（）函数

2.5.1strcmp函数的原型（字符串比较）

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

strcmp函数是一个一个字符比较，如果str1所指向的字符大于str2所指向的字符，返回大于0的数，如果str1所指向的字符小于str2所指向的字符，返回小于0的数，如果相等，继续比较下一对字符，直到比到\0为止，如果比到\0依然相等，那么返回0（字符串长度相等的情况）

2.5.2举例说明

strcmp("abcd","abcd");//返回值为0
两段字符串相同返回0

strcmp("abc","abcd");//返回值为负数
第一个字符串的第四个字符为\0,与第二个字符串的d比较是小于的，返回一个负数

strcmp("abcd","abc");//返回值为正数
d与\0比较是大于的，返回一个正数

strcmp("abs","abcd");//返回值为正数
第一个字符串的第三个字符s与第二个字符串的c比较是大于的，返回一个正数，后面的都不用比较了

strcmp("abcd","abs");//返回值为负数
第一个字符串的第三个字符c与第二个字符串的s比较是小于的，返回一个负数，后面的都不用比较了

2.5.3模拟实现strcmp（）函数

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 != NULL);
	assert(str2 != NULL);
	while (*str1 == *str2)//如果两个字符相等，那么进入循环
	{
		if (*str1 == '\0')//如果两个字符相等并且其中一个字符为\0，那么这两个字符串都走到了结尾，所以这两个字符串相等，直接返回0
			return 0;
		str1++;
		str2++;//不等于\0就使指针指向下一个位置,然后继续比较
	}
	return *str1 - *str2;//如果两个字符不相等，那么用str1指向的字符减去str2指向的字符，也就是两个字符的ASCLL码相减的到一个整数
}

2.6 strstr（）函数

2.6.1strstr函数的原型（字符串查找）

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

函数返回字符串str2在字符串str1中第⼀次出现的位置

2.6.2举例说明

int main()
{
	char arr[100] = "1234567890";
	char brr[] = "456";
	printf("%s",strstr(arr,brr) );
	return 0;
}

上面这段代码的输出结果为4567890

2.6.3模拟strstr（）函数

char* my_strstr(const char* str1, const char* str2)
{
	if (!*str2)//如果str2没有字符，那么结尾为\0,\0的ASCLL码值为0，非0为真，就直接返回str1的起始地址
		return (char*)str1;
	char* cp = (char*)str1;
	char* s2;
	char* s1;
	while (*cp)
	{
		s1 = cp;//因为我们要比较一段字符，当我们找到第一个字符时，需要往后比较剩余的字符是否相同
		s2 = (char*)str2;

		while (*s1 && *s2 && !(*s1 - *s2))//如果s1和s2所指向的字符都不为\0,并且两个字符相同，那么两个字符向后走，比较其他的字符
			s1++, s2++;
		if (!*s2)//如果s2走到了\0，那么说明字符串找到了，我们就返回第一个相同字符的地址
			return cp;
		cp++;//如果没找到，就继续cp++，用后面的字符和str2的第一个字符比较
	}
	return NULL;//如果没有找到，就返回空指针
}

这个是目前最复杂的模拟实验

2.7strtok()函数

2.7.1strtok函数的原型（切分字符串）

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

使用注意：

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

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

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

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

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

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

2.7.2举例说明

int main()
{
	char str1[] = "[email protected]";
		char str2[] = "@.";//定义被切割的节点
		char str3[100];
		char *str4 = NULL;
		strcpy(str3, str1);
		for (str4 = strtok(str3, str2); str4 != NULL; str4 = strtok(NULL, str2))
		{
			printf("%s\n", str4);
		}
	return 0;
}

2.8strncpy()函数

2.8.1strncpy函数的原型（拷贝n个字符）

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

num表示需要拷贝的字符数

2.8.2举例说明

int main()
{
	char arr[] = "1231231";
	char brr[] = "8888";
	strncpy(arr, brr, 4);
	printf("%s", arr);
	return 0;
}

输出结果为88881231

2.8.3模拟实现strncpy（）函数

char*my_strncpy(char* dest, const char* src, size_t num)
{
	char* ret = dest;
	while (num)
	{
		*dest++ = *src++;
		num--;
	}
	return ret;
}

2.9strncat（）函数

2.9.1strncat函数的原型

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

strncat函数的形参num表示要拼接的字符个数，最后补一个\0，同样要保证目标空间足够大

2.9.2举例说明

int main()
{
	char arr[20] = "1231231";
	char brr[] = "8888";
	strncat(arr, brr, 4);
	printf("%s", arr);
	return 0;
}

输出结果为12312318888

2.9.3模拟实现strncat（）函数

char* my_strncat(char* dest,const char* src, size_t x)
{
	assert(dest && src); 
	char* ret = dest;
	while (*dest)
	{
		dest++;
	}
	while (x)
	{
		*dest++ = *src++;
		x--;
	}
	return ret;
}

2.10strncmp（）函数

2.10.1strncmp函数的原型

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

 num表示要比较的字符个数

2.10.2举例说明

int main()
{
	char arr[20] = "1231231";
	char brr[] = "1237";
	printf("%d", strncat(arr, brr, 2));
	return 0;
}

 2.10.3模拟实现strncmp（）函数

int my_strcmp(char* arr1, char* arr2,size_t x)
{
	while (*arr1 == *arr2)
	{
		if (*arr1 == '\0')
		{
			return 0;
		}
		x--;
		if (x == 0)
		{
			break;
		}
		arr1++;
		arr2++;
	}
	return *arr1 - *arr2;
}

3.字符分类函数

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

函数	如果参数符合下列条件，就返回非零的数
iscntrl	任何控制字符
isspace	空白字符：空格 ‘ ’，换页 ‘\f’,换行 '\n', 回车 '\r',制表符'\t',  垂直制表符 '\v'
isdigit	十进制数字0~9
isxdigit	十六进制数字，包括所有十进制数字，小写字符a~f，大写字符A~F
islower	小写字母a~z
isupper	大写字母A~Z
isalpha	字母a~z或A~Z
isalnum	字母或者数字a~z，A~Z，0~9
ispunct	标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

以上这些函数形参和返回值都类似，我们以islower为例：

int islower ( int c );

islower 是能够判断参数部分的 c 是否是小写字⺟的。
通过返回值来说明是否是小写字母，如果是小写字母就返回非0的整数，如果不是小写字母，则返回0

4.字符转换函数

C语言提供了两个字符转换函数

头文件也为ctype.h

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

使用用例

#include 
#include 
int main ()
{
int i = 0;
char str[] = "Test String.\n";
char c;
while (str[i])
{
c = str[i];
if (islower(c))
c = toupper(c);
putchar(c);
i++;
}
return 0;
}