字符和字符串函数

求字符串长度

strlen

size_t strlen(const char *str);//返回字符串中'\0'前面出现字符的个数

 模拟实现

//计数器方式
int my_strlen(const char *str)
{
	int count = 0;
	while (*str++)
	{
		count++;
	}
	return count;
}

//递归方式
int my_strlen(const char *str)
{
	if (*str == '\0')
		return 0;

	return 1 + my_strlen(str + 1);
}

//指针-指针
int my_strlen(const char *str)
{
	char *ptr = str;
	while (*ptr)
	{
		ptr++;
	}

	return ptr - str;
}

长度不受限制字符串函数

strcpy

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

源字符串必须以'\0'结束,会将源字符串的'\0'拷贝到目标空间,目标空间必须足够大

模拟实现

char *my_strcpy(char *dst, const char *str)
{
	assert(dst);
	assert(str);

	char *ret = dst;
	while ((*ret++ = *str++))
	{
		;
	}

	return dst;
}

 strcat

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

 字符串拼接源字符串以'\0'结尾,目标空间必须足够大,

 模拟实现

char *my_strcat(char *dst, const char *str)
{
	assert(dst);
	assert(str);

	char *ret = dst;

	while (*ret)
	{
		ret++;
	}
	while ((*ret++ = *str++))
	{
		;
	}
	return dst;
}

strcmp

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

第一个字符串大于第二个字符串,返回一个大于0的数字

第一个字符串等于第二个字符串 ,返回0

第一个字符串小于第二个字符串,返回一个小于0的数字

模拟实现

int my_strcmp(const char *str1, const char *str2)
{
	while (*str1 != '\0' && *str2 != '\0' && *str1 == *str2)
	{
		str1++, str2++;
	}

	if (*str1 == '\0' && *str2 == '\0')
		return 0;
	else
	{
		if (*str1 > *str2)
			return 1;
		else if (*str1 < *str2)
			return -1;
		else
			return 0;

	}
}

长度受限制的字符串函数

strncpy

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

拷贝num个字符从源字符串到目标字符串,如果源字符串的长度小于num,拷贝完源字符串后,在目标字符串后追加0,知道num个

模拟实现

char* my_strncpy(char *des, const char *sstr, int count)
{
	char *ret = des;
	assert(src && des);
	while (count && (*ret++ = *str++))
	{
		count--;
	}
	if (count>0)
	{
		while (--count)
		{
			*ret++ = '\0';
		}
	}
	else
	{
		*ret = '\0';
	}
	return des;
}

strncat

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

模拟实现

char *my_strncat(char *dst, const char *str, int count)
{
	assert(str);

	char *ret = dst;
	while (*++ret)
	{
		;
	}

	while (count && (*ret++ = *str++))
	{
		count--;
	}
	*ret = '\0';

	return dst;
}

strncmp

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

模拟实现

int my_strncmp(const char *dst, const char *str, int n)
{
	assert(dst && str);

	while (n)
	{
		if (*dst > *str)
		{
			return 1;
		}
		else if (*dst < *str)
		{
			return -1;
		}
		dst++,str++;
		n--;
	}
	if (n == 0)
		return 0;
}

 字符串查找

strchr

char *strchr( const char *string, int c );//返回第一个出现目标字符的指针

strrchr

char *strrchr( const char *string, int c );//从后往前找第一个出现目标字符的指针

strpbrk 

char *strpbrk( const char *string, const char *strCharSet );//返回第一个字符串中第一个出现在第二个字符串中的字符的地址

 strstr

char *strstr( const char *string, const char *strCharSet );//找子串

模拟实现

char *my_strstr(const char *str1, const char *str2)
{
	assert(str1);
	assert(str2);

	char *cp = (char *)str1;
	char *substr = (char *)str2;
	char *s1 = NULL;

	if (*str2 == '\0')
		return NULL;

	while (*cp)
	{
		s1 = cp;
		substr = str2;
		while (*s1 && *substr && (*s1 = *substr))
		{
			*s1++, substr++;
		}
		if (*substr == '\0')
			return cp;
		cp++;
	}
}

strspn

size_t strspn( const char *str1, const char *str2 );//返回str1字符串中开始部分匹配str2字符串中的字符个数

strcspn

size_t strcspn( const char *str1, const char *str2);//返回str1指向字符串中开始部分出现的不在str2指向字符串中的字符个数

strtok

char *strtok( char *str, const char *dst );//dst定义了分隔符的字符集合
//找到str中的下一个分隔符标记并用\0结尾,返回一个指向这个标记的指针
//第一个参数不为NULL,找到str中的第一个标记,保存他在字符串中位置
//第一个参数为NULL,函数在同一个字符串中被保存的位置开始,查找下一个标记
//字符串中不存在更多的标记,返回NULL

错误信息报告

strerror

char *strerror( int errnum );//返回错误码,对应的错误信息

内存操作函数(操作基本单元是字节)

memcpy 

void *memcpy( void *dest, const void *src, size_t count );//void *可以被定义,不能被解引用

函数从src的位置开始向后复制count个字节的数据到dest的内存位置

遇到'\0'并不会停下来,如果dest和src有重叠,其复制结果未定义

模拟实现

void *my_memcpy(void *dest, void *src, int count)
{
	assert(dest);
	assert(src);

	void *ret = dest;
	while (count--)
	{
		*(char *)ret = *(char *)src;
		ret = (char *)ret + 1;
		src = (char *)src + 1;
	}

	return dest;
}

memmove

void *memmove( void *dest, const void *src, size_t count );

memmove函数处理的源内存块和目标内存块是可以重叠的,

模拟实现

void *my_memmove(void *dst, const void *src, int count)
{
	assert(dst);
	assert(src);

	char *d = (char *)dst;
	char *s = (char *)src;

	if (d > s && d < s + count)//从右向左,考虑内存重叠
	{
		d = d + count - 1;
		s = s + count - 1;

		while (count--)
		{
			*d = *s;
			d--, s--;
		}
	}
	else
	{
		while (count--)
		{
			*d = *s;
			d++, s++;
		}
	}

	return dst;
}

memset

void *memset( void *dest, int c, size_t count );

以字节为基本单位,初始化每个字节为c

memcmp

int memcmp( const void *buf1, const void *buf2, size_t count );

比较buf1和buf2指针开始的count个字节

memchr

void *memchr( const void *buf, int c, size_t count );