手写函数strlen(), strcpy(), strstr(), strcat(), strcmp(), memcpy(), strchr(), strlwr(), strupr()

strlen()函数

描述
C 库函数 size_t strlen(const char *str) 计算字符串 str 的长度，直到空结束字符，但不包括空结束字符。
声明
下面是 strlen() 函数的声明。

size_t strlen(const char *str)

参数
str – 要计算长度的字符串。
返回值
该函数返回字符串的长度。

实现:

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

strstr()函数

描述
C 库函数 char *strstr(const char *haystack, const char *needle) 在字符串 haystack 中查找第一次出现字符串 needle 的位置，不包含终止符 ‘\0’。
声明
下面是 strstr() 函数的声明。

char *strstr(const char *haystack, const char *needle)

参数
haystack – 要被检索的 C 字符串。
needle – 在 haystack 字符串内要搜索的小字符串。
返回值
该函数返回在 haystack 中第一次出现 needle 字符串的位置，如果未找到则返回 null。

实现:

int strstr(char *string, char *substring) {
	if(string == NULL || substring == NULL)
		return -1;
 
	int lenstr = strlen(string);
	int lensub = strlen(substring);
 
	if(lenstr < lensub)
		return -1;
 
	int i,j;
 
	for(int i = 0; i < lenstr-lensub; ++i) {
		for(j = 0; j < lensub; ++j) {
			if(string[i+j] != substring[i])
				break;
		}
 
		if(j == lensub)
			return i;
	}
 
	return -1;
 
}

strcat()函数

描述
C 库函数 char *strcat(char *dest, const char *src) 把 src 所指向的字符串追加到 dest 所指向的字符串的结尾。

声明
下面是 strcat() 函数的声明。

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

参数
dest – 指向目标数组，该数组包含了一个 C 字符串，且足够容纳追加后的字符串。
src – 指向要追加的字符串，该字符串不会覆盖目标字符串。
返回值
该函数返回一个指向最终的目标字符串 dest 的指针。

实现:

char* strcat(char* strDest, const char* strSrc) {
	char* address = strDest;
	assert( (strDest != NULL) && (strSrc != NULL) );
 
	while(*strDest != '\0')	//当strDest='\0'时结束,即为字符串的结尾,将strSrc添加到此处
		strDest++;
 
	while(*strSrc != '\0')
		*strDest++ = *strSrc++;
 
	*strDest = '\0';
 
	return address;
}
 

strcmp()函数

描述
C 库函数 int strcmp(const char *str1, const char *str2) 把 str1 所指向的字符串和 str2 所指向的字符串进行比较。
声明
下面是 strcmp() 函数的声明。

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

参数
str1 – 要进行比较的第一个字符串。
str2 – 要进行比较的第二个字符串。
返回值
该函数返回值如下：

如果返回值小于 0，则表示 str1 小于 str2。
如果返回值大于 0，则表示 str1 大于 str2。
如果返回值等于 0，则表示 str1 等于 str2。

实现:

//方法1：

int strcmp(const char* str1, const char* str2) {
	assert( (str1 != NULL) && (str2 != NULL) );
	int ret = 0;
 
	while( !(ret = *(unsigned char*)str1 - *(unsigned char*)str2) && *str1 ) {
	//ret=0,相等,相等时要确定两个字符不为'\0';  ret!=0时,循环结束,判断ret值
		str1++;
		str2++;
	}
	if(ret > 0)
		return 1;
	else if(ret < 0)
		return -1;
 
	return 0;
}

//方法2：
int strcmp(const char* str1, const char* str2)
{
 
    while(*str1 == *str2 && *str1 != '\0')
    {
        ++str1;
        ++str2;
    }
    return *str1 - *str2;
}

strcpy()函数

描述
C 库函数 char *strcpy(char *dest, const char *src) 把 src 所指向的字符串复制到 dest。

需要注意的是如果目标数组 dest 不够大，而源字符串的长度又太长，可能会造成缓冲溢出的情况。
声明
下面是 strcpy() 函数的声明。

char *strcpy(char *dest, const char *src)

参数
dest – 指向用于存储复制内容的目标数组。
src – 要复制的字符串。
返回值
该函数返回一个指向最终的目标字符串 dest 的指针。

实现:

char *strcpy(char *strDes, const char *strSrc) {
	if(strSrc == NULL || strDes == NULL)
		return NULL;
 
	char *address = strDes;
 
	while( (*strDest++ = *strSrc++) != '\0');
 
	return address;
 
}

memcpy()函数

描述
C 库函数 void *memcpy(void *str1, const void *str2, size_t n) 从存储区 str2 复制 n 个字节到存储区 str1。
声明
下面是 memcpy() 函数的声明。

void *memcpy(void *str1, const void *str2, size_t n)

参数
str1 – 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
str2 – 指向要复制的数据源，类型强制转换为 void* 指针。
n – 要被复制的字节数。
返回值
该函数返回一个指向目标存储区 str1 的指针。
功能:将str指向地址为起始地址的连续n个字节的数据复制到以dest指向地址为起始地址的空间内,函数返回一个指向dest的指针.

实现:

void* memcpy(void *dest, const void *src, size_t n) {
	if(dest == NULL || src == NULL)
		return NULL;
 
	char* pdest = (char*)dest;
	char* psrc = (char*)src;
 
	while(n--)
		*pdest++ = *psrc++;
 
	return dest;
}

memmove()函数

描述
C 库函数 void *memmove(void *str1, const void *str2, size_t n) 从 str2 复制 n 个字符到 str1，但是在重叠内存块这方面，memmove() 是比 memcpy() 更安全的方法。如果目标区域和源区域有重叠的话，memmove() 能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中，复制后源区域的内容会被更改。如果目标区域与源区域没有重叠，则和 memcpy() 函数功能相同。

声明
下面是 memmove() 函数的声明。

void *memmove(void *str1, const void *str2, size_t n)

参数
str1 – 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
str2 – 指向要复制的数据源，类型强制转换为 void* 指针。
n – 要被复制的字节数。
返回值
该函数返回一个指向目标存储区 str1 的指针。

//考虑内存重叠的memcpy函数 优化的点
void* memmove(void* dst, const void* src, size_t n)  {  
    char* s_dst;  
    char* s_src;  
    s_dst = (char*)dst;  
    s_src = (char*)src;  
    if(s_dst>s_src && (s_src+n>s_dst)) { //第二种内存覆盖的情形。
        s_dst = s_dst+n-1;  
        s_src = s_src+n-1;  
        while(n--) {  
            *s_dst-- = *s_src--;  
        }  
    }else {  
        while(n--) {  
            *s_dst++ = *s_src++;  
        }  
    }  
    return dst;  
}

注意：
C 标准库也提供了地址重叠时的内存拷贝函数：memmove()，那么为什么还要考虑重写memcpy()函数呢?

原因在于：因为 memmove() 函数的实现效率问题，该函数把源字符串拷贝到临时 buf 里，然后再从临时 buf 里写到目的地址，增加了一次不必要的开销。

memcpy和memmove对比分析：
https://zhuanlan.zhihu.com/p/70873246

strchr()函数

描述
C 库函数 char *strchr(const char *str, int c) 在参数 str 所指向的字符串中搜索第一次出现字符 c（一个无符号字符）的位置。

声明
下面是 strchr() 函数的声明。

char *strchr(const char *str, int c)

参数
str – 要被检索的 C 字符串。
c – 在 str 中要搜索的字符。
返回值
该函数返回在字符串 str 中第一次出现字符 c 的位置，如果未找到该字符则返回 NULL。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include<assert.h>
#include<string.h>
char *my_strchr(const char *psrc, char ch)
{
	assert(psrc);
	while (*psrc)
	{
		if (*psrc == ch)
		{
			return psrc;
		}
		else
			psrc++;
	}
	return NULL;
}
int main()
{
	char arr[] = "abcdeg";
	char ch = 'b';
	const char *ret = my_strchr(arr, ch);
	printf("%s\n", ret);
	system("pause");
	return 0;
}

strlwr()和strupr()函数

strlwr函数原型

#include <string.h>

char *strlwr(char *str)

strlwr()用于将字符串中的字符转换为小写，其原型为：
【参数说明】str为要转换的字符串。
【返回值】返回转换后的小写字符串，其实就是将str返回。

strupr函数原型

#include <string.h>

char *strupr(char *str);

strupr()用于将字符串中的字符转换为小写，其原型为：
【参数说明】str为要转换的字符串。
【返回值】返回转换后的大写写字符串，其实就是将str返回。

char *my_strlwr(char*str)
{
	assert(str != NULL);
	char*temp = str;
	while (*temp)
	{
		if (*temp > 'A' && *temp < 'Z')
		{
			*temp += 0x20;
		}
		temp++;
	}
	return str;
}
 
char *my_strupr(char*str)
{
	assert(str != NULL);
	char*temp = str;
	while (*temp)
	{
		if (*temp > 'a' && *temp < 'z')
		{
			*temp -= 0x20;
		}
		temp++;
	}
	return str;
}

参考链接：
https://blog.youkuaiyun.com/amoscykl/article/details/86091269?spm=1001.2014.3001.5506

https://blog.youkuaiyun.com/weixin_40697000/article/details/89958478?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-9&spm=1001.2101.3001.4242