【C语言】常见字符函数和字符串函数-创新互联

1.1strlen

size_t strlen(const char* str);

字符串已经'\0'作为结束标志，strlen函数返回的是在字符串中'\0'前面出现的字符个数（不包含'\0'）。

创新互联公司凭借在网站建设、网站推广领域领先的技术能力和多年的行业经验，为客户提供超值的营销型网站建设服务，我们始终认为：好的营销型网站就是好的业务员。我们已成功为企业单位、个人等客户提供了网站制作、成都网站制作服务，以良好的商业信誉，完善的服务及深厚的技术力量处于同行领先地位。

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

注意函数的返回值为size_t，是无符号整形（易错点）。

下面看一段代码：

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

我们知道无符号整形的运算操作的是补码，代码中的3-6可以看做是3+（-6），补码相加的结果是11111111111111111111111111111101对于一个有符号的数字，最高位是1为负数，但是返回值是无符号的数，当这个补码被当做一个无符号的数字处理的时候是一个非常大的正数，所以程序运行结果为str2>str1。

1.2strlen的模拟实现

strlen的模拟实现有三种方法：计数器、递归、指针。

方法一（计数器）

size_t my_strlen1(const char* str)
{
	assert(str);
	unsigned int count = 0;
	while (*str != '\0')
	{
		str++;
		count++;
	}
	return count;
}

方法二（递归）

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

方法三（指针）

size_t my_strlen3(const char* str)
{
	assert(str);
	const char* dest = str;//没有修改，只移查找
	while ('\0' != *dest)
	{
		dest++;
	}
	return dest - str;
}

2.1strcpy

char* strcpy(char* dest, const char* src);
Copies the C string pointed by source into 
the array pointed by destination,including
the terminating null character.

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

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

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

目标空间必须可变。

2.2strcpy的模拟实现

char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);
	char* start = dest;//记录进入的原始的dest
	while (*dest++ = *src++)//后置++
	{
		;
	}
	return start;
}

3.1strcat

char* strcat(char* dest, const char* src);

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

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

目标空间可修改。

3.2strcat的模拟实现

strcat的模拟实现和strcpy的模拟实现有着异曲同工之妙，只是在strcpy模拟实现的基础上加了一个找目标字符串中的'\0'。

char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* start = dest;
	//找目标字符串中的'\0'
	while ('\0' != *dest)
	{
		dest++;
	}
	//追加
	while (*dest++ = *src++)
	{
		;
	}
	return start;
}

4.1strcmp

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

标准规定：

第一个字符串大于第二个字符串，则返回大于0的数字。

第一个字符串等于第二个字符串，则返回0。

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

4.2strcmp的模拟实现

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')//比较的字符串相等
			return 0;
		str1++;
		str2++;
	}
	return *str1 - *str2;
}

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

strncpy、strncat、strncmp

char * strncpy ( char * destination, const char * source, size_t num );
char * strncat ( char * destination, const char * source, size_t num );
int strncmp ( const char * str1, const char * str2, size_t num );

这是三个函数和长度受限制的字符串函数是相似的，只不过使用传参时多一个参数num,需要指明操作字符串的字节数目，在模拟实现的时候，只要多传递一个参数，然后限制参数的大小即可实现。

6.1strstr

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

Returns a pointer to the first occurrence of str2 in str1,or a null pointer if str2 is not part of str1.

使用举例：

int main()
{
	char str[] = "This is a simple string";
	char* pch;
	pch = strstr(str, "simple");
	strncpy(pch, "sample", 6);
	puts(str);
	return 0;
}

6.2strstr的模拟实现

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* s1 = str1;//记录str1的位置
	const char* s2 = str2;//记录str2的位置
	const char* cur = str1;//记录移动的位置
	while (*cur)
	{
		s1 = cur;
		s2 = str2;
		while (*s1 && *s2 && (*s1 == *s2))//判断条件
		{
			s1++;
			s2++;
		}
		if ('\0' == *s2)
			return (char*)cur;
		cur++;
	}
	return NULL;
}

7.1strtok

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

sep参数是个字符串，定义了用作分隔符的字符集和。

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

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

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

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

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

下面看一个程序：

int main()
{
	char str[] = "- This, a sample string.";
	char* pch;
	printf("Splitting string \"%s\" into tokens:\n", str);
	pch = strtok(str, " ,.-");
	while (pch != NULL)
	{
		printf("%s\n", pch);
		pch = strtok(NULL, " ,.-");
	}
	return 0;
}

这种代码看起来并不是很好，所以可以对以上代码进行改进：

int main()
{
	char* p = "zhangpengwei@bitedu.tech";
	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);
	}
}

7.2strerror

char* strerror(int errnum);

返回错误码所对应的错误信息。

#include#include#include//必须包含的头文件
int main()
{
	FILE* pFile;
	pFile = fopen("unexist.ent", "r");
	if (pFile == NULL)
		printf("Error opening file unexist.ent: %s\n", strerror(errno));
	//errno: Last error number
	return 0;
}

7.3memcmp

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

比价从ptr1和ptr2指针开始的num个字节

返回值如下：

8.1memcpy 

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

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 '\0' 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。

8.2memcpy的模拟实现

void* my_memcpy(void* dest, const void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	while (count--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}

	return ret;
}

9.1memmove

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

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

9.2memmove的模拟实现

void* my_memmove(void* dest, const void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	if (dest< src)
	{
		//从前往后
		while (count--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//从后往前
		while (count--)
		{
			*((char*)dest+count) = *((char*)src+count);
		}
	}
	return ret;
}

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

分享标题：【C语言】常见字符函数和字符串函数-创新互联
转载来于：http://cdkjz.cn/article/djhhhp.html