字符串+内存函数详解（c语言）

前言

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。字符串常量适用于那些对它不做修改的字符串函数。

字符串函数

1.strlen

strlen是求字符串长度的函数，求的是’\0’之前的字符个数，有三种方式去实现

1.1 计数器方式

#include <stdio.h>
#include <assert.h>
size_t my_strlen(const char* str)
{
	assert(str != NULL);//防止传进来的指针为空指针
	int count = 0;
	while (*str++)
	{
		count++;
	}
	return count;
}

1.2 递归方式

#include <stdio.h>
#include <assert.h>
size_t my_strlen(const char* str)
{
	assert(str != NULL);
	if (*str)
	{
		return 1 + my_strlen(str+1);
	}
	else
	{
		return 0;
	}
}

1.3 指针相减方式

#include <stdio.h>
#include <assert.h>
size_t my_strlen(const char* str)
{
	assert(str != NULL);
	const char* p = str;
	while (*str)
	{
		str++;
	}
	return str - p;
}

2.strcmp

strcmp是比较两个字符串的函数

#include <assert.h>
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2 && *str2)
	{
		str1++;
		str2++;
	}
	return *str1 - *str2;
}

3.strcpy

strcpy是拷贝字符串的函数

#include <assert.h>
char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

4. strcat

strcat可以在一个字符串的后面追加字符串

#include <assert.h>
char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

5.strncpy

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

• 拷贝num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

6. strncat

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

• 将源字符串的前num个字符附加到目标，再加上终止字符。
• 如果源字符串的长度小于num，则只将整个源字符串追加到目标空间。

7.strncmp

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

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

8.strstr

strstr是查找字符串的函数

#include <stdio.h>
#include <assert.h>
char* my_strstr(const char* dest, const char* src)
{
	assert(dest && src);
	const char* str1, * str2;
	while (*dest)
	{
		if (*dest == *src)
		{
			str1 = dest;
			str2 = src;
			while (str1 == str2 && *str2)
			{
				str1++;
				str2++;
			}
			if (!*str2)
			{
				return dest;
			}
		}
		dest++;
	}
	return NULL;
}

上面这种实现方式效率显然比较低，可以运用KMP算法提高效率，在此就不做过多赘述了。

9.strtok

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

• sep参数是个字符串，定义了用作分隔符的字符集合
• 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
• strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
• strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
• strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
• 如果字符串中不存在更多的标记，则返回 NULL 指针。

10.strerror

char * strerror ( int errnum );

返回错误码，所对应的错误信息。
例子：

/* strerror example : error list */
#include <stdio.h>
#include <string.h>
#include <errno.h>//必须包含的头文件
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;
}

内存函数

1.memcpy

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

void * memcpy ( void * dst, const void * src, size_t count)
{
void * ret = dst;
assert(dst);
assert(src);
//copy from lower addresses to higher addresses
	while (count--)
{
	*(char *)dst = *(char *)src;
	dst = (char *)dst + 1;
	src = (char *)src + 1;
}
	return(ret);
}

2.memmove

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

void* my_memmove(void* dest,const void* src,size_t num)
{
	void* ret = dest;
	if (src > dest)
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return ret;
}

3.memcmp

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

• 比较从ptr1和ptr2指针开始的num个字节
• 返回值如下