C语言从入门到精通——进阶5 字符串函数和内存函数

字符函数和字符串函数

C语言本身没有字符串类型，字符串通常放在常量字符串中或字符数组中

strlen

数到\0停止，但不包含\0 

返回值是size_t,是无符号的

 typedef unsigned int     size_t;

//模拟实现strlen

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

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

strcpy

 源字符串必须包含'\0'，连带'\0'一起拷贝过去 

目标空间要有足够的空间存放源字符串

目标空间必须可以修改 

//模拟实现strcpy

#include <assert.h>
 
void my_strcpy(char* dest, char* src)
{
	assert(dest!=NULL);//断言,头文件<assert.h>，表达式为真时无事发生，表达式为假时报错
	assert(src != NULL);
	while (*dest++ = *src++)
	{
		;
	}
 
}

strcat

 //模拟实现strcat

char* my_strcat(char* dest, const char* str)
{
	char* ret = dest;
	assert(dest != NULL);
	assert(src);

	//1.找到目的字符串的'\0'
	while (*dest != '\0')
	{
		dest++;
	}
	//2.追加
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}

自己给自己追加会导致死循环( 因为destination中的‘\0’被覆盖)

strcmp

 //模拟实现strcmp

int my_strmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	//比较
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
		{
			return 0;//相等
		}
		str1++;
		str2++;
	}
	/*if (*str1 > *str2)
		return 1;
	else
		return -1;*/
	return (*str1 - *str2);
}

 长度受限制的字符串函数

strncpy

num大于source长度时，补\0 

strncat

strncmp

 strstr

 //模拟实现strstr

char* my_strstr( char* p1,  char* p2)
{
	assert(p1 != NULL);
	assert(p2 != NULL);
	char* s1 = p1;
	char* s2 = p2;
	char* cur = p1;
	if (*p2 == '\0')
	{
		return p1;
	}
	while (*cur)
	{
		while((*s1 != '\0')&&(*s2!='\0')&&(*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return cur;//找到子串
		}
		cur++;
	}
	return NULL;//找不到子串
}

系统实现方式：

char * __cdecl strstr (
        const char * str1,
        const char * str2
        )
{
        char *cp = (char *) str1;
        char *s1, *s2;

        if ( !*str2 )
            return((char *)str1);

        while (*cp)
        {
                s1 = cp;
                s2 = (char *) str2;

                while ( *s2 && !(*s1-*s2) )
                        s1++, s2++;

                if (!*s2)
                        return(cp);

                cp++;
        }

        return(NULL);

}

 strtok

 //使用方式

int main()
{
	char arr[] = "dsjgfu&bdsjbf.djsbh(ndskn.com";
	const char* p = ".(&";
	char buf[1024] = {};
	strcpy(buf, arr);
	char* ret = NULL;
	for (ret = strtok(arr, p); ret != NULL;ret=strtok(NULL,p))//ret！=NULL证明找到一个串
	{
		printf("%s\n", ret);
	}
	return 0;
}

strerror

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

 errno是一个全局的错误码的变量，由库函数维护 //头文件<errno.h>

当C语言的库函数在执行过程中，发生了错误，就会把对应的错误码，赋值到errno中

 //使用实例

字符分类函数

头文件 #include <ctype.h>

字符转换函数

内存函数

 memcpy  

//模拟实现memcpy

void* my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);

	while (num--)
	{
		*(char*)dest = *(char*)src;
		dest=(char*)dest+1;
		src=(char*)src+1;
	}
	return ret;
}

模拟实现的my_memcpy只能实现不重叠的内存拷贝，要是重叠情况需要用memmove函数 

memmove  

 //模拟实现my_memmove

dest指针在src前面时，从前向后拷贝；其余情况，从后向前拷贝

void* my_memmove(void* dest, const void* src, size_t count)
{
	void* ret = dest;
	assert(dest != NULL);
	assert(src != NULL);

	if (dest<src)
	{
		while(count--)//从前向后
		{
			*(char*)dest = *(char*)src;
			++(char*)dest;
			++(char*)src;
		}
		
	}
	else
	{
		while (count--)//从后向前
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	return ret;
}

memcmp

内存比较

 memset

内存设置，改的单位是字节