【C语言】字符串函数原理实现汇总

欢迎来到我的博客！
以下为C语言中常见字符串的实现

Strlen

strlen函数从字符的首地址开始遍历，以 '\0' 为结束标志，然后将计算的长度返回，计算的长度并不包含'\0'。

size_t Strlen(const char* ptr) {
	assert(ptr);//断言防止空指针
	size_t count = 0;
	while (*ptr != '\0') {
		ptr++;
		count++;
	}
	return count;
}

函数形参以const修饰，不对齐做出修改，只计算长度。由于 strlen函数的返回类型为size_t即unsigned int,因此我们设计时也使用该类型，将count声明为size_t，count用于记录长度。然后使用while循环遍历字符串，当为\0，结束，并返回count。

Strcpy

是将一个字符串复制到另一块空间地址中 的函数，'\0'是停止拷贝的终止条件，同时也会将 '\0' 也复制到目标空间。

char* Strcpy(char* destination, const char* source)
{
	assert(source && destination);
	char* ret = destination;
	while (*destination++ = *source++) {
		;
	}
	return ret;
}

Strcat

将源字符串的副本追加到目标字符串,destination中的终止null字符被 source的第一个字符覆盖，并且 null 字符包含在由 destination 中两者的串联形成的新字符串的末尾。

char* Strcat(char* des,const char* source) {
	assert(des && source);
	char* ret = des;
	//找到des的末尾('\0'地址)
	while (*des) {
		*des++;
	}
	while (*des++ = *source++) {
		;
	}
	return ret;
}

Strcmp

比较两个字符串

将 C 字符串 str1 与 C 字符串 str2 进行比较，此函数开始比较每个字符串的第一个字符。
如果它们彼此相等，则继续以下对，直到字符不同或达到终止null字符为止。

int Strcmp(const char* ptr1,const char* ptr2){
	assert(*ptr1 && *ptr2);
	while (*ptr1 == *ptr2) {
		if (*ptr1 == '\0') {
			return 0;
		}
		*ptr1++;
		*ptr2++;
	}
	return *ptr1 - *ptr2;
}

StrInsert

void Strinsert(char* ptr1, int p,char* ptr2) {
    int len1 = strlen(ptr1);
    int len2 = strlen(ptr2);
    if (p<0 || p>len1) {
        return;
    }
    //先将ptr1数组后的字符往后移动p个位置  
    for (int i = 0; i <= len1 - p + 1; i++) {
        ptr1[len2 + len1 - i] = ptr1[len1 - i];
    }
    for (int i = 0; i < len2; i++) {
        ptr1[p - 1 + i] = ptr2[i];
    }
}

StrDelete

void Strdelete(char* ptr, int pos, int len) {
	int len2 = strlen(ptr);
	if (pos < 0 || pos > len2) {
		return;
	}
	if (len >= 0 && len < len2 - pos + 1) {
		//这里+1多拷贝一次，拷贝'\0'
		for (int i = 0; i <= len2 - pos - len+1; i++) {
			ptr[pos - 1 + i] = ptr[pos + len - 1 + i];
		}
	}
	else if (pos + len - 1 == len2) {
		ptr[pos - 1] = '\0';
	}
}

SubString

void Substring(char* T, const char* S, int pos, int len) {
    int len2 = strlen(S);
    if (pos < 1 || pos > len2) {
        return;
    }
    if (pos + len > len2) {
        return;
    }
    strncpy(T, S + pos, len);
    //添加结束符
    T[len] = '\0';
}

StrStr

该函数返回指向str1中第一次出现的str2的指针，如果str2不是str1的一部分，则返回一个null指针。

int Strstr(const char* str1, const char* str2) {
	assert(str1 && str2);
	const char* s1 = str1;
	const char* s2 = str2;
	const char* p = str1;//记录每次查找开始位置
	while (*p) {
		s1 = p;
		s2 = str2;
		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2) {
			s1++;
			s2++;
		}
		if (*s2 == '\0') {
			return (char*)p;
		}
		*p++;//从下一字符开始重新对照
	}
	return NULL;
}

该函数返回str1中第一次出现的str2对应字符的下标

int Strstr(const char* str1, const char* str2) {
	assert(str1 && str2);
	const char* s1 = str1;
	const char* s2 = str2;
	const char* p = str1;//记录每次查找开始位置
	int n = 0;//记录下标
	while (*p) {
		s1 = p;
		s2 = str2;
		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2) {
			s1++;
			s2++;
		}
		if (*s2 == '\0') {
			return n;
		}
		n++;
		*p++;//从下一字符开始重新对照
	}
	return NULL;
}

StrIndex

该函数返回首次出现的位置

int Strindex(char* str1, int pos, char* str2) {
		assert(str1 && str2);
		const char* s1 = str1;//查找str1
		const char* s2 = str2;//查找str2
		const char* p = str1 + pos;
		int n = pos;
		while (*p) {
			s1 = p;
			s2 = str2;
			while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2) {
				s1++;
				s2++;
			}
			if (*s2 == '\0') {
				return n+1;
			}
			n++;
			*p++;
		}
		return 0;
}

StrReplace

char* StrReplace(const char* str, const char* T, const char* V) {
    // 计算新字符串的长度
    int len1 = strlen(T);
    int len2 = strlen(V);
    int count = 0;
    const char* p = str;
    //在字符串中搜索字符串T，记录次数
    while ((p = strstr(p, T)) != NULL) {
        count++;
        p += len1;
    }
    //计算出新字符串的长度
    int len3 = strlen(str) + count * (len2 - len1);
    //创建新数组，分配内存
    char* str2 = (char*)malloc((len3 + 1) * sizeof(char));
    if (str2 == NULL) {
        return NULL;
    }
    p = str;
    char* str3 = str2;
    // 当前字符是子字符串T的开始位置就复制，并使指针指向复制的内容之后
    while (*p != '\0') {
        if (strstr(p, T) == p) {
            strcpy(str3, V);
            str3 += len2;//新字符串指针前进V的距离
            p += len1;   //原字符串指针前进T的长度
        }
        else {
            *str3++ = *p++;//不符合就拷贝其余的
        }
    }
    *str3 = '\0'; //补上'\0'
    return str2;
}

StrEmpty

#include <stdbool.h>
bool StrEmpty(const char* str) {
    if (str == NULL) {
        return true;
    }
    while (*str != '\0') {
        if (*str != ' ' && *str != '\t' && *str != '\n') {
            return false; 
        }
        str++;
    }
    return true;  // 如果遍历完都没有非空字符，则认为是空字符串,返回true
}

StrClear

void StrClear(char* ptr) {
	ptr[0] = '\0';
}

StrDestory

void StrDestory(char* ptr) {
	if (ptr != NULL) {
		free(ptr);
	}
}

Memcpy

void* Memcpy(void* dest, const void* src, size_t num) {
	assert(dest && src);
	void* ret = dest;
	while (num--) {
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

Memmove

void* Memmove(void* dest, void* src, size_t num) {
	assert(dest && src);
	void* ret = dest;
	//分情况讨论从后向前，从前往后
		//从前向后
	if (dest < src) {
			while (num--) {
		          *(char*)dest = *(char*)src;
		          dest = (char*)dest + 1;
		          src = (char*)src + 1;
	        }
	}
    	//从后向前
	else {
		while (num--) {
			*(char*)dest = *((char*)src + num);
		}
	}
	return ret;
}

---

---

感谢您的阅读