C语言----string函数和memory函数

Posted 2021-06-26 4nc414g0n

1.字符串函数

头文件<string.h>
strlen()
strcpy()
strcat()
strcmp()
strncpy()
strncat()
strncmp()
strstr()
strtok()
strerror()

1）strlen()

size_t strlen ( const char * str );
返回类型为无符号整形
所以当遇到strlen("hi")-strlen("hello");结果会是一个正数

模拟实现strlen

#include <stdio.h>
#include <assert.h>
int my_strlen(const char* dest)
{
	int count=0;
	assert(dest);
	while(*dest!='\\0')
	{
		dest++;
		count++;
	}
	return count;
}

2）strcpy()

char * strcpy ( char * destination, const char * source );
源字符串必须以 '\\0' 结束。
会将源字符串中的 '\\0' 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变

模拟实现strcpy()

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

3）strcat()

char * strcat ( char * destination, const char * source );
源字符串必须以 '\\0' 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改

注意：

当字符串自己给自己追加时，函数先覆盖掉目标地址的‘\\0’，所以会无限追加下去，为了安全我们选用strncpy()

模拟实现strcat()

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

4）strcmp()

int strcmp ( const char * str1, const char * str2 );
规定：
1. 第一个字符串大于第二个字符串，则返回大于0的数字
2. 第一个字符串等于第二个字符串，则返回0
3. 第一个字符串小于第二个字符串，则返回小于0的数字

模拟实现strcmp()

#include <stdio.h>
#include <assert.h>
int my_strcmp(const char* s1, const char* s2)
{
	while(*s1==*s2)
	{
		if(*s1=='\\0')
		{
			return 0;
		}
		s1++;
		s2++;
	}
	// if(*s1>*s2)
	// {
	// 	return 1;
	// }
	// else
	// {
	// 	return -1;
	// }
	return *s1-*s2;
}

5）strncpy()

char * strncpy ( char * destination, const char * source, size_t num );
拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个

库函数实现

char * __cdecl strncpy (
        char * dest,
        const char * source,
        size_t count
        )
{
        char *start = dest;

        while (count && (*dest++ = *source++) != '\\0')    
        /* copy string */
                count--;

        if (count)   /* pad out with zeroes */
                while (--count)
                        *dest++ = '\\0';

        return(start);
}

6）strncat()

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

库函数实现

char * __cdecl strncat (
        char * front,
        const char * back,
        size_t count
        )
{
        char *start = front;

        while (*front++)
                ;
        front--;

        while (count--)
                if ((*front++ = *back++) == 0)
                        return(start);

        *front = '\\0';
        return(start);
}

7）strncmp()

int strncmp ( const char * str1, const char * str2, size_t num );
比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。

库函数实现

int __cdecl strncmp
(
    const char *first,
    const char *last,
    size_t      count
)
{
    size_t x = 0;

    if (!count)
    {
        return 0;
    }

    /*
     * This explicit guard needed to deal correctly with boundary
     * cases: strings shorter than 4 bytes and strings longer than
     * UINT_MAX-4 bytes .
     */
    if( count >= 4 )
    {
        /* unroll by four */
        for (; x < count-4; x+=4)
        {
            first+=4;
            last +=4;

            if (*(first-4) == 0 || *(first-4) != *(last-4))
            {
                return(*(unsigned char *)(first-4) - *(unsigned char *)(last-4));
            }

            if (*(first-3) == 0 || *(first-3) != *(last-3))
            {
                return(*(unsigned char *)(first-3) - *(unsigned char *)(last-3));
            }

            if (*(first-2) == 0 || *(first-2) != *(last-2))
            {
                return(*(unsigned char *)(first-2) - *(unsigned char *)(last-2));
            }

            if (*(first-1) == 0 || *(first-1) != *(last-1))
            {
                return(*(unsigned char *)(first-1) - *(unsigned char *)(last-1));
            }
        }
    }

    /* residual loop */
    for (; x < count; x++)
    {
        if (*first == 0 || *first != *last)
        {
            return(*(unsigned char *)first - *(unsigned char *)last);
        }
        first+=1;
        last+=1;
    }

    return 0;
}

8）strstr()

const char * strstr ( const char * str1, const char * str2 );
char * strstr ( 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.
如果找到了就返回arr2的首字符地址如果没找到就返回空指针

模拟实现strstr()

#include <stdio.h>
#include <assert.h>
char* my_strstr(const char* str1,const char* str2)
{
	assert(str1 && str2);
	const char* s1=str1;
	const char* s2=str2;
	const char* cp = str1;//cp记录str1相同的首字符
	if(*s2=='\\0')
	{
		return (char*)str1;
	}
	while(*cp)
	{
		s1 = cp;
		s2=str2;
		while(*s1 && *s2 && (*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if(*s2 == '\\0')
		{
			return (char*)cp;
		}
		cp++;
	}
	return NULL;
}

9）strtok()

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

库函数实现

#include	<string.h>

#ifdef _PIC16
far char *
strtok(register far char * s1, register const char * s2)
#else /* _PIC16 */
char *
strtok(register char * s1, register const char * s2)
#endif /* _PIC16 */

{
#ifdef _PIC16
	static far char *	sp;
#else /* _PIC16 */
	static char *	sp;
#endif /* _PIC16 */

	if(!s1)
		s1 = sp;
	if(!s1)
		return NULL;
	s1 += strspn(s1, s2);	/* skip leading delimiters */
	if(!*s1)
		return sp = NULL;
	sp = s1 + strcspn(s1, s2);
	if(*sp)
		*sp++ = 0;
	else
		sp = 0;
	return s1;
}

10）strerror()

char * strerror ( int errnum );
返回错误码，所对应的错误信息
#include <errno.h>是必须包含的头文件

例：printf (“Error opening file unexist.ent: %s\\n”,strerror(errno));
int errno全局错误码

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;
}

输出No such file or directory

2.字符操作函数

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 );
字符转换大小写

3.内存函数

memcpy()
memmove()
memcmp()
memset()
1）memcpy()

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

1. C99规定函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
2. 这个函数在遇到 '\\0' 的时候并不会停下来。如果source和destination有任何的重叠，复制的结果都是未定义的
3. 在VS中memcpy可以像memmove一样实现重叠部分复制，C99中并未要求此功能

模拟实现memcpy()

#include <stdio.h>
#include <assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret=dest;
	assert(dest && src);
	while(num--)
	{
		*(char*)dest = *(char*)src;
		dest=(char*)dest+1;
		src=(char*)src+1;
	}
	return  ret;
}

---

2）memmove()

void * memmove ( void * destination, const void * source, size_t num );
和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

模拟实现memmove()

#include<stdio.h>
#include <assert.h>
void* my_memmove(void* dest, const void* src, size_t num)
{
	void* ret=dest;
	assert(dest && src);
	//从前向后copy(my_memcpy)
	if(dest<src)
	{
		while(num--)
		{
			*(char*)dest = *(char*)src;
			dest=(char*)dest+1;
			src=(char*)src+1;
		}
	//从后向前copy
	}
	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个字节

库函数实现

#include	<string.h>
memcmp(const void *s1, const void *s2, size_t n)
{
	while(n-- != 0)  {
		if(*((const unsigned char *)s1) != *((const unsigned char *)s2))
			return *((const unsigned char *)s1) - *((const unsigned char *)s2);
		(*(const unsigned char **)&s1)++;
		(*(const unsigned char **)&s2)++;
	}
	return 0;
}

---

4）memset()

void * memset ( void * ptr, int value, size_t num );
设置指向ptr地址的前num个字节为value

库函数实现

#include	<string.h>
#ifdef _PIC16
far void *
memset(far void * p1, int c, register size_t n)
#else /*  _PIC16 */
void *
memset(void * p1, int c, register size_t n)
#endif /* _PIC16 */
{

#ifdef _PIC16
	register far char *	p;
#else /*  _PIC16 */
	register char *		p;
#endif /* _PIC16 */

	p = p1;
	while(n--)
		*p++ = c;
	return p1;
}