【C语言】字符函数和字符串函数

一、长度不受限字符串函数

1.strlen函数

介绍

size_t strlen ( const char * str );

头文件：#include<string.h>

作用：求字符串长度

注：①字符串以'\0'作为结束标志，strlen函数返回的是字符串中'\0'前面出现的字符个数(不包含'\0')

②函数返回值为size_t，是无符号的

 

int main()
{
	const char* str = "abcdef";

	size_t len1 = strlen("abcdef");
	size_t len2 = strlen(str);

	printf("%d\n", len1);//6
	printf("%d\n", len2);//6


	return 0;
}

模拟实现

1.计数器方式

 

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

 2.递归方式

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

 3.指针-指针

注：指针-指针的绝对值是指针之间的元素个数

 

int my_strlen(char *s)
{
    char *p = s;
    while(*p != ‘\0’ )
        p++;
    return p-s;
}

 2.strcpy函数

介绍

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

 

头文件：#include<string.h>

作用：将源字符串拷贝到目标空间

注：①源字符串必须以'\0'结束

②会将源字符串中的'\0'拷贝到目标空间

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

④目标空间必须可变

 

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

模拟实现

char *my_strcpy(char *dest, const char*src)
{
    char *ret = dest;
    assert(dest != NULL);//包含头文件#include<assert.h>
    while((*dest++ = *src++))
    {
        ;
    }
    return ret;
}

3.strcat函数

介绍

void my_strcat(char* dest, const char* src)；

头文件：#include<string.h>

作用：从目标空间遇到的第一个'\0'开始将源字符串拷贝过去

注：①目标空间必须足够大，而且必须可变

②目标空间中必须得有'\0'

③源字符串也得有'\0',最后要将\0'拷贝到目标空间

④源字符串和目标字符串不能是同一个字符串

int main()
{
	char arr1[20] = "abc";
	char arr2[] = "def";
	strcat(arr1, arr2);
	printf("%s\n", arr1);

	return 0;
}

模拟实现

void my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
	//1.找到目标空间的末尾
	while (*dest)
	{
		dest++;
	}
	//2.数据追加
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

 

 4.strcmp函数

介绍

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

头文件：#include<string.h>

作用：比较两个字符串的大小，有三种返回值

①如果第一个字符串大于第二个字符串，则返回大于0的数字；

②如果第一个字符串等于第二个字符串，则返回值为0；

③如果第一个字符串小于第二个字符串，则返回小于0的数字。

注：①字符串比较的是两个字符串对应的ASCII码值

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abg";
	int ret = strcmp(arr1, arr2);
	printf("%d\n", ret);

	return 0;
}

模拟实现

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		str1++;
		str2++;
	}
	if (*str1 > *str2)
		return 1;
	else
		return -1;
}

 更巧妙地返回值的写法：

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		str1++;
		str2++;
	}
	return *str1 - *str2;
}

二、长度受限制字符串函数

 1.strncpy函数

介绍

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

头文件：#include<string.h>

作用：从源字符串中拷贝num个字符到目标空间

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

int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "abdwesayt";
	strncpy(arr1, arr2, 4);
	printf("%s\n", arr1);
	return 0;
}

 2.strncat函数

介绍

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

头文件：#include<string.h>

作用：将源字符串num个字符追加到目标空间的尾部

注：①如果追加数量大于源数组的大小，那么源数组放完全部元素直接结束，不会添加到指定个数

int main()
{
	char arr1[20] = "abc";
	char arr2[] = "xcvb";
	strncat(arr1, arr2, 6);
	printf("%s\n", arr1);
	return 0;
}

 3.strncmp函数

介绍

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

头文件：#include<string.h>

作用：比较两个字符串大小，直到出现一个字符不一样或者一个字符串结束或者num个字符全部比较完

注：①返回值和strcmp函数返回值一样

int main()
{
	char arr1[20] = "abcdefg";
	char arr2[] = "abcdefs";
	int ret = strncmp(arr1, arr2, 7);
	printf("%d\n", ret);

	return 0;
}

三、字符串查找比较函数

1..strstr函数

介绍

const char * strstr ( const char * str1, const char * str2 );- 在C语言里的声明
char * strstr (char * str1, const char * str2 );

头文件：#include<string.h>

作用：在str1找str2第一次出现的位置，如果没有，则返回一个空指针

注：①如果字符串2为空字符串，则返回的是字符串1的起始位置

int main()
{
	char arr1[20] = "abcdefg";
	char arr2[] = "de";
	char* ret = strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("找不到\n");
	}
	else
	{
		printf("%s\n", ret);
	}

	return 0;
}

模拟实现

const char* my_strstr(const char* str1, const char* str2)
{
	const char* cp;//记录开始匹配的位置
	const char* s1;//遍历str1指向的字符串
	const char* s2;//遍历str2指向的字符串
	assert(str1 && str2);
	cp = str1;
	while (*cp)
	{
		s1 = cp;
		s2 = str2;
		while (*s1 && *s2 && *s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return cp;
		cp++;
	}
	return NULL;
}

 注：在这里我们用的是一种暴力求解方式，不够高效，如果想优化求解方式，可以了解KMP算法

 2.strtok函数

介绍

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

头文件：#include<string.h>

作用：通过指针sep传入的分隔符将字符串str分割成多个字符串，并返回第一个子字符串的指针

注：①sep参数是个字符串，定义了用作分隔符的字符集合

②strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容
并且可修改

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

④strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标
记
⑤如果字符串中不存在更多的标记，则返回 NULL 指针

int main()
{
	char arr[] = "zpengwei@yeah.net";

	char buf[200] = { 0 };
	strcpy(buf, arr);//拷贝一份arr里的内容，再进行切割，不用改变arr里的内容

	char* p = "@.";
	char* s = strtok(buf, p);//arr[] --> "zpengwei\0yeah.net"
	printf("%s\n", s);//zpengwei

	s = strtok(NULL, p);//
	printf("%s\n", s);//yeah

	s = strtok(NULL, p);//
	printf("%s\n", s);//net

	s = strtok(NULL, p);//
	printf("%s\n", s);//NULL

	return 0;
}

 当我们采用上面的方式时，就代表着代码没有变化了，因此我们可以利用strtok的特性（如果从第二次开始如果传入NULL参数，则会在上一次字符串被保存的位置开始查找下一个标记），通过循环进行优化

int main()
{
	char arr[] = "zpengwei@yeah.net";

	char buf1[200] = { 0 };
	strcpy(buf1, arr);

	char buf2[200] = { 0 };
	strcpy(buf2, arr);

	char* p = "@.";
	char* s = NULL;
	//第一次使用需要传入目标数组，之后再用，只需要str为空指针
	for (s = strtok(buf1, p); s != NULL; s = strtok(NULL, p))//可以循环使用
	{
		printf("%s\n", s);
	}

	char* p2 = ".";
	for (s = strtok(buf2, p2); s != NULL; s = strtok(NULL, p2))//可以循环使用
	{
		printf("%s\n", s);
	}

	return 0;
}

 四、字符串错误信息报告

strerror函数

介绍

char * strerror ( int errnum );

头文件：#include<string.h>

作用：返回错误码对应的错误信息

注：①在使用时要包含#include<errno.h>头文件，定义了错误码对应的错误信息

②strerror只会将错误码翻译成对应的错误信息，但不会自动打印出来。

③使用perror函数可以翻译并自动打印出来错误信息。

④因此perror = printf + strerror

int main()
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d: %s\n", i, strerror(i));
	}
	return 0;
}
举例：
//0: No error - 无错误
//1: Operation not permitted - 操作不允许
//2 : No such file or directory - 该文件/路径不存在
//3 : No such process  - 无进程
//4 : Interrupted function call - 中断的系统调用
//5 : Input / output error - 输入输出I/O错误
//6 : No such device or address - 设备/地址不存在
//7 : Arg list too long - 参数列表过长
//8 : Exec format error - 执行格式错误
//9 : Bad file descriptor - 错误文件编号

五、 字符操作函数

字符分类函数

函数	如果他的参数符合下列条件就返回真
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	任何可打印字符，包括图形字符和空白字符

 字符转换

int tolower ( int c );//大写字母转换成小写字母
int toupper ( int c );//小写字母转换成大写字母

六、内存操作函数

1.memcpy函数

介绍

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

头文件：#include<string.h>

作用：从source的位置开始向后复制num个字节的数据到destination的内存位置

注：①在遇到 '\0' 的时候并不会停下来

②如果source和destination有任何的重叠，复制的结果都是未定义的
③使用memcpy函数实现重叠的空间拷贝是没有问题的，但是，标准值规定，memcpy来实现不重叠的内存的拷贝，而重叠的内存的拷贝，由memmove来实现

int main()
{
	int arr1[10] = { 0 };
	int arr2[] = { 1,2,3,4,5 };
	//把arr2中的前5个整数的数据，拷贝放在arr1中
	memcpy(arr1, arr2, 20);

	return 0;
}

模拟实现

void* my_memcpy(void* dest,const void* src, size_t sz)
{
	void* ret = dest;//需要有一个void*的指针返回值
	assert(dest && src);
	while (sz--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
		//++(char*)dest;//可能会出现编译错误
		//++(char*)src;
	}
  return ret;
}

int main()
{
	int arr1[10] = { 0 };
	int arr2[] = { 1,2,3,4,5 };
	my_memcpy(arr1, arr2, 20);

	return 0;
}

 

 2.memmove函数

介绍

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

头文件：#include<string.h>

作用：和memcpy的作用是一样的，区别在于memmove函数处理的源内存块和目标内存块是可以重叠的

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr, arr + 2, 20);
	int i;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

模拟实现

如果目标空间和源空间重叠，分为从前向后拷贝还是从后向前拷贝

void* my_memmove(void* dest, void* src, size_t sz)
{
	void* ret = dest;//需要有一个void*的指针返回值
	assert(dest && src);
	if (dest < src)
	{
		//从前向后拷贝
		while (sz--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (sz--)
		{
			*((char*)dest + sz) = *((char*)src + sz);
		}
	}
	return ret;
}

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr, arr + 2, 20);
	int i;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

 3.memcmp函数

介绍

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

头文件：#include<string.h>

作用：比较两个字符串中num个字节内存空间的大小，返回值和strcmp

注：①返回值和strcmp函数以及strncmp函数返回值一样

int memcmp ( const void * ptr1, const void* ptr2, size_t num );
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7 };
	//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 
	//<-                                  -> - 比较这13个内存的大小
	int arr2[] = { 1,2,3,7 };
	//01 00 00 00 02 00 00 00 03 00 00 00 07 00 00 00 
	//
	int ret = memcmp(arr1, arr2, 13);
	printf("%d\n", ret);

	return 0;
}

4.memset函数

介绍

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

头文件：#include<string.h>

作用：从ptr位置开始将num个内存空间设置为指定的value值

注：①memset是设置内存的

②是以字节为单位设置内存的

int main()
{
	char arr[] = "hello world";
	memset(arr + 6, 'x', 3);
	printf("%s\n", arr);
}

 

 

int main()
{
	int arr[10] = { 0 };
	memset(arr, 1, 40);

	return 0;
}

本次介绍函数到这里就结束了，下次再见。