一.字符串函数的模拟实现
1. strlen的模拟实现
strlen(const char* str)：strlen 函数用于计算字符串的长度，即字符串中字符的个数，不包括字符串结尾的空字符 '\0'。它接受一个指向字符串开头的指针，并通过遍历字符串的每个字符来确定长度。它返回一个 size_t 类型的值，表示字符串的长度。
#include <stdio.h>
size_t strlen(const char* str) {
size_t length = 0;
while (str[length] != '\0') {
length++;
}
return length;
}
int main() {
const char* str = "Hello, World!";
size_t length = strlen(str);
printf("Length of the string: %zu\n", length);
return 0;
}
2. strcpy的模拟实现
strcpy(char* dest, const char* src)：strcpy 函数用于将一个字符串（源字符串）复制到另一个字符串（目标字符串）中。它接受两个参数，第一个参数是目标字符串的指针，第二个参数是源字符串的指针。函数会将源字符串的内容复制到目标字符串中，直到遇到源字符串的结尾字符 '\0'。它返回指向目标字符串的指针。
#include <stdio.h>
char* strcpy(char* dest, const char* src) {
char* temp = dest;
while (*src != '\0') {
*dest = *src;
dest++;
src++;
}
*dest = '\0';
return temp;
}
int main() {
char source[] = "Hello, World!";
char destination[20];
strcpy(destination, source);
printf("Copied string: %s\n", destination);
return 0;
}
3. strcat的模拟实现
strcat(char* dest, const char* src)：strcat 函数用于将一个字符串（源字符串）追加到另一个字符串（目标字符串）的末尾。它接受两个参数，第一个参数是目标字符串的指针，第二个参数是源字符串的指针。函数会将源字符串的内容追加到目标字符串的末尾，并在最后添加一个结尾字符 '\0'。它返回指向目标字符串的指针。
#include <stdio.h>
char* strcat(char* dest, const char* src) {
char* temp = dest;
while (*dest != '\0') {
dest++;
}
while (*src != '\0') {
*dest = *src;
dest++;
src++;
}
*dest = '\0';
return temp;
}
int main() {
char str1[50] = "Hello";
char str2[] = ", World!";
strcat(str1, str2);
printf("Concatenated string: %s\n", str1);
return 0;
}
4. strcmp的模拟实现
strcmp(const char* str1, const char* str2)：strcmp 函数用于比较两个字符串的大小关系。它接受两个参数，分别是要比较的两个字符串的指针。函数会逐个比较字符串中的字符，直到遇到不同的字符或其中一个字符串的结尾字符 '\0'。如果两个字符串相等，函数返回值为 0；如果第一个字符串小于第二个字符串，返回值为负数；如果第一个字符串大于第二个字符串，返回值为正数。
#include <stdio.h>
int strcmp(const char* str1, const char* str2) {
while (*str1 && (*str1 == *str2)) {
str1++;
str2++;
}
return *(unsigned char*)str1 - *(unsigned char*)str2;
}
int main() {
const char* str1 = "Hello";
const char* str2 = "World";
int result = strcmp(str1, str2);
if (result < 0) {
printf("str1 is less than str2\n");
} else if (result > 0) {
printf("str1 is greater than str2\n");
} else {
printf("str1 is equal to str2\n");
}
return 0;
}
5. strncpy函数的模拟实现
strncpy(char* dest, const char* src, size_t n)：strncpy 函数用于将指定长度的源字符串复制到目标字符串中。它接受三个参数，第一个参数是目标字符串的指针，第二个参数是源字符串的指针，第三个参数是要复制的字符数。如果源字符串的长度小于指定的字符数，那么目标字符串会被复制的字符填充直到达到指定的字符数。函数会在最后一个复制的字符之后添加结尾字符 '\0'。它返回指向目标字符串的指针。
#include <stdio.h>
char* strncpy(char* dest, const char* src, size_t n) {
char* temp = dest;
while (n > 0 && *src != '\0') {
*dest = *src;
dest++;
src++;
n--;
}
while (n > 0) {
*dest = '\0';
dest++;
n--;
}
return temp;
}
int main() {
const char* src = "Hello, World!";
char dest[20];
size_t n = 10;
strncpy(dest, src, n);
printf("Copied string: %s\n", dest);
return 0;
}
6. strncat函数的模拟实现
strncat(char* dest, const char* src, size_t n)：strncat 函数用于将指定长度的源字符串追加到目标字符串的末尾。它接受三个参数，第一个参数是目标字符串的指针，第二个参数是源字符串的指针，第三个参数是要追加的字符数。如果源字符串的长度小于指定的字符数，那么源字符串的全部内容都会被追加到目标字符串的末尾。函数会在追加完源字符串后，在目标字符串的末尾添加结尾字符 '\0'。它返回指向目标字符串的指针。
#include <stdio.h>
char* strncat(char* dest, const char* src, size_t n) {
char* temp = dest;
while (*dest != '\0') {
dest++;
}
while (n > 0 && *src != '\0') {
*dest = *src;
dest++;
src++;
n--;
}
*dest = '\0';
return temp;
}
int main() {
char str1[50] = "Hello";
char str2[] = ", World!";
size_t n = 7;
strncat(str1, str2, n);
printf("Concatenated string: %s\n", str1);
return 0;
}
7. strstr函数的模拟实现
strstr(const char* str, const char* substr)：strstr 函数用于在一个字符串中查找子字符串的出现位置。它接受两个参数，第一个参数是要搜索的字符串的指针，第二个参数是要查找的子字符串的指针。函数会在目标字符串中搜索子字符串的第一次出现，并返回一个指向该位置的指针。如果子字符串不存在于目标字符串中，函数返回 NULL。
#include <stdio.h>
const char* strstr(const char* str, const char* substr) {
if (*substr == '\0')
return str;
while (*str) {
const char* temp_str = str;
const char* temp_substr = substr;
while (*temp_str && *temp_substr && (*temp_str == *temp_substr)) {
temp_str++;
temp_substr++;
}
if (*temp_substr == '\0')
return str;
str++;
}
returnstr;
}
int main() {
const char* str = "Hello, World!";
const char* substr = "World";
const char* result = strstr(str, substr);
if (result != NULL) {
printf("Substring found at position: %ld\n", result - str);
} else {
printf("Substring not found\n");
}
return 0;
}二.内存函数的模拟实现
1. memcpy函数的模拟实现
memcpy(void* dest, const void* src, size_t n)：memcpy 函数用于将一段内存块的内容从源地址复制到目标地址。它接受三个参数，第一个参数是目标地址的指针，第二个参数是源地址的指针，第三个参数是要复制的字节数。函数会将源地址开始的连续字节复制到目标地址中，包括字节中的所有数据和字节的值。它返回指向目标地址的指针。
#include <stdio.h>
void* memcpy(void* dest, const void* src, size_t n) {
char* dest_ptr = (char*)dest;
const char* src_ptr = (const char*)src;
while (n > 0) {
*dest_ptr = *src_ptr;
dest_ptr++;
src_ptr++;
n--;
}
return dest;
}
int main() {
int src[] = {1, 2, 3, 4, 5};
int dest[5];
size_t n = sizeof(src);
memcpy(dest, src, n);
for (int i = 0; i < 5; i++) {
printf("%d ", dest[i]);
}
printf("\n");
return 0;
}
2. memmove函数的模拟实现
memmove(void* dest, const void* src, size_t n)：memmove 函数类似于 memcpy 函数，也用于将一段内存块的内容从源地址复制到目标地址。它的区别在于，memmove 函数能够处理源地址和目标地址重叠的情况，而 memcpy 函数则不能。如果源地址和目标地址重叠，memmove 函数会先将数据复制到临时缓冲区，然后再从缓冲区复制到目标地址，以确保数据的正确性。它返回指向目标地址的指针。
#include <stdio.h>
void* memmove(void* dest, const void* src, size_t n) {
char* dest_ptr = (char*)dest;
const char* src_ptr = (const char*)src;
if (dest_ptr < src_ptr) {
while (n > 0) {
*dest_ptr = *src_ptr;
dest_ptr++;
src_ptr++;
n--;
}
} else if (dest_ptr > src_ptr) {
dest_ptr += n;
src_ptr += n;
while (n > 0) {
dest_ptr--;
src_ptr--;
*dest_ptr = *src_ptr;
n--;
}
}
return dest;
}
int main() {
int arr[] = {1, 2, 3, 4, 5};
memmove(arr + 2, arr, 3 * sizeof(int));
for (int i = 0; i < 5; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}希望以上的库函数模拟，可以对你产生帮助。
