IT数码 购物 网址 头条 软件 日历 阅读 图书馆
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓ 		图片批量下载器
↓批量下载图片,美女图库↓ 		图片自动播放器
↓图片自动播放器↓ 		一键清除垃圾
↓轻轻一点,清除系统垃圾↓
开发: C++知识库 Java知识库 JavaScript Python PHP知识库 人工智能 区块链 大数据 移动开发 嵌入式 开发工具 数据结构与算法 开发测试 游戏开发 网络协议 系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑 笔记本 显卡 显示器 固态硬盘 硬盘 耳机 手机 iphone vivo oppo 小米 华为 单反 装机 图拉丁
 
   -> C++知识库 -> C语言——strlen、strcpy、strcat、strcmp、strstr、memcpy、memmove函数的使用和模拟 -> 正文阅读

[C++知识库]C语言——strlen、strcpy、strcat、strcmp、strstr、memcpy、memmove函数的使用和模拟

C语言字符函数、字符串函数、内存函数

strlen函数

strlen函数介绍

size_t strlen ( const char * str )

参数：需要一个字符串的地址，const对其进行修饰，使其不能修改
返回值：返回字符串的长度，无符号整型（size_t），所以打印时最好用%ud
注意：1.计算的是字符串的长度，字符串以\0结尾
2.该函数计算的是\0之前的字符数，不包含\0
3.使用所有的字符函数、字符串函数、内存函数都必须包含头文件#include <string.h>

strlen函数的使用

#include <stdio.h>
#include <string.h>
int main()
{
	char arr0[] = "abcd";//abcd\0
	char arr1[] = { 'a','b','c','d' };//abcd，无法求长度，但可以加'\0'求长度
	//char arr1[] = { 'a','b','c','d'，'\0'};//正确
	char arr2[10] = { 'a','b','c','d' };//abcd\0\0……，'d'之后都初始化为0，由于是char即'\0'

	int len0 = strlen(arr0);//4
	int len1 = strlen(arr1);//随机值
	int len2 = strlen(arr2);//4

	printf("%d\n", len0);
	printf("%d\n", len1);
	printf("%d\n", len2);

	if (strlen("abc") > strlen("abcd"))//正确
	{
		printf(">\n"); 
	}
	else
	{
		printf("<\n");
	}
	if (strlen("abc") - strlen("abcd")>0)//错误，无符号-无符号的结果是无符号
	{
		printf(">\n");
	}
	else
	{
		printf("<\n");
	}
	return 0;
}

输出结果：
在这里插入图片描述

1.字符串的结束标志是’\0’，strlen计算以’\0’作为结束标志，计算之前的字符数，而arr2中不含有’\0’，所以会继续向后找，直到找到’\0’为止，计算结果是个随机值，所以必须保证字符串中有’\0’
2.strlen函数的返回值是无符号整数，所以相减还是无符号整数

模拟实现strlen函数

#include <stdio.h>
#include <string.h>
#include <assert.h>
int MyStrlen(const char* str)
{
	int count=0;
	assert(str != NULL);
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "abcdef";
	int len = MyStrlen(arr);
	printf("%d\n", len);//6
	return 0;
}

1.采用计数的形式，利用while循环判断，只要不是’\0’，count会一直加，str不断指向下一个字符的地址
2.assert()是断言函数，当括号中的条件为假（即0）时，会自动打印错误信息，为了避免传过来的是空指针，所以使用assert()函数，assert(str)或assert(str != NULL)
3.利用const来保证str指向的内容不会被修改

采用递归的方式实现

#include <stdio.h>
#include <string.h>
#include <assert.h>
int MyStrlen(const char* str)
{
	assert(str != NULL);
	if (*str!= '\0')
	{
		return 1 + MyStrlen(str+1);
	}
	else
		return 0;
}
int main()
{
	char arr[] = "abcdef";
	int len = MyStrlen(arr);
	printf("%d\n", len);//6
	return 0;
}

采用指针 - 指针的方式实现

#include <stdio.h>
#include <string.h>
#include <assert.h>
int MyStrlen(const char* str)
{
	const char* start = str;
	assert(str!= NULL);
	while (*str)
	{
		str++;
	}
	return str- start;

}
int main()
{
	char arr[] = "abcdef";
	int len = MyStrlen(arr);
	printf("%d\n", len);//6
	return 0;
}

1.两个指针相减代表的是元素的个数

strcpy函数

复制字符串，将source指向的字符串复制到destination所指向的地址中，包括终止空字符

strcpy函数介绍

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

参数：从source处指向的地址的内容复制到 destination指向的地址中去
返回值：返回的是目标空间的起始地址
注意：1.源字符串必须以 ‘\0’ 结束
2.会将源字符串中的 ‘\0’ 拷贝到目标空间
3.目标空间必须可变且足够大，以确保能存放源字符串

strcpy函数的使用

#include <stdio.h>
#include <string.h>

int main()
{

	char arr[] = "******";
	char arr1[10] = { 0 };
	char arr2[] = "abc";
	char arr3[] = "123456789";
	strcpy(arr, arr2);
	strcpy(arr1, arr3);

	printf("%s\n", arr);
	printf("%s\n", arr1);

	return 0;
}

输出结果：
在这里插入图片描述

1.从上述图片可以看出把’\0’拷贝了过去
2.利用%s读取第一个’\0’之前的内容

模拟实现strcpy函数

#include <stdio.h>
#include <string.h>
#include <assert.h>

void MyStrcpy(char* dest, const char* src)
{
	assert(src != NULL);
	assert(dest != NULL);
	while(*src)
	{
		*dest = *src;
		dest++;
		src++;
	}
		*dest = *src;

}

int main()
{
	char arr[] = "******";
	char arr1[] = "abc";
	MyStrcpy(arr, arr1);
	printf("%s\n", arr);
	return 0;
}

代码优化

#include <stdio.h>
#include <string.h>
#include <assert.h>

char* MyStrcpy(char* dest, const char* src)
{
	assert(src && dest);
	char* start = dest;
	while(*dest++ = *src++)
	{
		;
	}
	return start;
}

int main()
{
	char arr[] = "******";
	char arr1[] = "abc";
	printf("%s\n", MyStrcpy(arr, arr1));
	return 0;
}

输出结果：
在这里插入图片描述

1.该函数返回目标空间的起始地址
2.利用断言函数确保dest和src不是空指针
3. while(*dest++ = *src++)，每一次循环先将 *dest = *src，根据 *dest是否为’\0’，来决定循环是否继续，然后src++,dest++，最后当 *dest==‘\0’时，循环中止，此时已经将’\0’拷贝了过去

strcat函数

strcat是字符串追加（连接）函数

strcat函数介绍

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

参数：destination是指向目标数组的指针，source 要追加的 C 字符串，不应与目标重叠
返回值：返回的是目标空间的起始地址
注意：1.源字符串必须以 ‘\0’ 结束
2.会将源字符串中的 ‘\0’ 拷贝到目标空间
3.目标空间必须可修改且足够大，以确保能存放源字符串
4.从目标字符串中的的’\0’开始追加，并且将目标字符串中的的’\0’覆盖，源字符串中的’\0’也会追加过去

strcat函数的使用

#include <stdio.h>
#include <string.h>
#include <assert.h>
int main()
{
	char arr[10] = "abc";
	char arr1[] = "def";
	strcat(arr, arr1);
	printf("%s\n", arr);//abcdef
	return 0;
}

输出结果：
在这里插入图片描述

在这里插入图片描述
第一种情况是正常追加字符串
第二种是自己给自己追加字符串，发现会陷入死循环，因为自身的’\0’被覆盖了，源字符串无法将’\0’拷贝过去，用来结束拷贝

模拟实现strcat函数

#include <stdio.h>
#include <string.h>
#include <assert.h>

void MyStrcat(char* dest, const char* src)
{
	while (*dest)
	{
		dest++;
	}
	while (*src)
	{
		*dest = *src;
		src++;
		dest++;
	}
	*dest = *src;
}


int main()
{
	char arr[10] = "abc";
	char arr1[] = "def";
	MyStrcat(arr, arr1);
	printf("%s\n", arr);//abcdef
	return 0;
}

代码优化

#include <stdio.h>
#include <string.h>
#include <assert.h>

char* MyStrcat(char* dest, const char* src)
{
	char* p = dest;
	assert(dest && src);
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *src++)
	{
		;
	}
	return p;
}

int main()
{
	char arr[10] = "abc";
	char arr1[] = "def";
	printf("%s\n", MyStrcat(arr,arr1));//abcdef
	return 0;
}

1.strcat的拷贝可以与strcpy结合起来，不过要先找到目标地址的’\0’，然后再进行拷贝

strcmp函数

比较两个字符串的大小

strcmp函数介绍

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

参数：将将 C 字符串 str1 与 C 字符串 str2 进行比较
返回值：str1>str2：返回>0的数值
????str1=str2：返回0
????str1<str2：返回<0的数值
注意：1.比较的是ASIIC码值，比如"abcd"是小于"ad"的，因为d的阿斯克码值大于b的阿斯克码值
2.此函数是逐个比较每个字符串中的字符，如果相同则继续向下比较，直到不同或到’\0’

strcmp函数的使用

#include <stdio.h>
#include <string.h>
#include <assert.h>

int main()
{
	char arr[] = "abcd";
	char arr1[] = "af";
	int ret = strcmp(arr, arr1);
	if (ret > 0)
	{
		printf(">\n");
	}
	else if (ret < 0)
	{
		printf("<\n");
	}
	else
	{
		printf("=\n");
	}
	printf("%d\n", ret);
	return 0;
}

输出结果：
在这里插入图片描述

1.由于b的ASIIC值小于f的ASIIC值，所以返回小于0的数

模拟实现strcmp函数

#include <stdio.h>
#include <string.h>
#include <assert.h>

int MyStrcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
	}
	if (*str1 < *str2)
	{
		return -1;
	}
	else
		return 1;
}

int main()
{
	char arr[] = "abc";
	char arr1[] = "abb";
	int ret = MyStrcmp(arr, arr1);
	printf("%d\n", ret);
	return 0;
}

代码优化

#include <stdio.h>
#include <string.h>
#include <assert.h>

int MyStrcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
	}
	return *str1 - *str2;
}

int main()
{
	char arr[] = "abc";
	char arr1[] = "abb";
	int ret = MyStrcmp(arr, arr1);
	printf("%d\n", ret);
	return 0;
}

strncpy函数

从字符串中复制字符

strncpy函数介绍

char * strncpy ( char * destination, const char * source, size_t num )

参数：destination：指向要在其中复制内容的目标数组的指针
source：要复制的 C 字符串
num：从源目标地址要赋值的字节数
返回值：返回目标空间的起始地址
注意：1.num是单位是字节
2.由于str前缀的都是操作字符串，char是一个字节，故num的个数就是几个字符

strncpy函数的使用

#include <stdio.h>
#include <string.h>

int main()
{
	char arr1[] = "hello world";
	char arr2[] = "1234";
	strncpy(arr1, arr2, 4);
	printf("%s",arr1);
	

	return 0;

}

输出结果：
在这里插入图片描述

1.将arr2的4个字节拷贝过去
2.如果拷贝10个过去，不足的部分会补’\0’
3.将源的第一个字符复制到目标。如果在复制 num 个字符之前找到源 C 字符串（由空字符表示）的末尾，则用零填充目标，直到向其写入了总共 num 个字符

strncat函数

从字符串追加字符

strncat函数介绍

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

参数：destination：指向目标数组的指针，目标数组应包含 C 字符串，并且足够大以包含串联的结果字符串，包括其他空字符
source：要追加的 C 字符串
num：要追加的最大字符数
返回值：返回目标空间的起始地址
注意：1.源的第一个字符追加到目标，以及终止空字符
2.如果源中 C 字符串的长度小于 num，则仅复制终止空字符之前的内容
3.目标空间要大
4.从目标空间’\0’的地方开始追加

strncat函数的使用

#include <stdio.h>
#include <string.h>

int main()
{
	char arr1[10] = "abc\0def";
	char arr2[] = "1234";
	strncat(arr1, arr2, 2);
	printf("%s",arr1);
	return 0;

}

输出结果：
在这里插入图片描述

1.从arr1的’\0’处开始追加
2.会在最后追加’\0’
3.如果arr2中的数目小于要追加的num，最后追加过去只会加一个’\0’

strncmp函数

strncmp函数介绍

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

参数：将将 C 字符串 str1 与 C 字符串 str2的num个数 进行比较
返回值：str1>str2：返回>0的数值
????str1=str2：返回0
????str1<str2：返回<0的数值
注意：1.比较的是ASIIC码值，比如"abcd"是小于"ad"的，因为d的阿斯克码值大于b的阿斯克码值
2.此函数是逐个比较每个字符串中的字符，如果相同则继续向下比较，直到不同或到’\0’

strncmp函数的使用

#include <stdio.h>
#include <string.h>

int main()
{
	char arr1[] = "abcde";
	char arr2[] = "abf";
	int ret = strncmp(arr1, arr2, 3);
	if (ret > 0)
	{
		printf(">\n");
	}
	else if (ret < 0)
	{
		printf("<\n");
	}
	else
	{
		printf("=\n");
	}
	return 0;
}

输出结果：
在这里插入图片描述

1.比较的前3个字符，c<f，所以打印<

strstr函数

strstr函数介绍

char * strstr ( const char *str1, const char * str2)

参数：str1要扫描的字符串，str2要匹配的字符串，总之就是看str1中是否有str2
返回值：返回指向str1中第一次出现str2的指针，如果str2不是str1的一部分，则返回空指针
注意：1.如果str1中找到str2后，返回指向str1中第一次出现str2的指针，此时打印的是str1中与str2相同的内容向后直到str1中的’\0’，停止打印

#include <stdio.h>
#include <string.h>
#include <assert.h>


int main()
{
	char arr[] = "abcdefgbcdh";
	char arr1[] = "bcd";
	//在arr中查找是否包含arr2数组
	//会返回第一次找到的地址
	char* ret = strstr(arr, arr1);
	if (ret == NULL)
	{
		printf("没找到\n");
	}
	else
	{
		printf("找到了：%s\n", ret);
	}

	return 0;
}

输出结果：
在这里插入图片描述

1.可以看到打印的bcdefgbcdh，有两个bcd，找到第一个后就开始向后打印

strstr函数的模拟实现

#include <stdio.h>
#include <string.h>
#include <assert.h>

char* MyStrstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* s1 = str1;
	const char* s2 = str2;
	const char* ptr = str1;

	if (*str2 == '\0')
	{
		return NULL;
	}
	while (*ptr)
	{
		s1 = ptr;
		s2 = str2;
		while (*s1 && *s2 && (*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return ptr;
		}
		ptr++;
	}
	return NULL;

}

int main()
{
	char arr[] = "bcdddefgbcdh";
	char arr1[] = "dde";
	//在arr中查找是否包含arr2数组
	//会返回第一次找到的地址
	char* ret = MyStrstr(arr, arr1);
	if (ret == NULL)
	{
		printf("没找到\n");
	}
	else
	{
		printf("找到了：%s\n", ret);
	}

	return 0;
}

输出结果：
在这里插入图片描述

在这里插入图片描述
1.将str1和str2分别赋给s1和s2，利用s1和s2的移动来遍历整个字符串
2.ptr用来记录字符相同的位置，起到一个标记作用，找到后作为起始位置返回
3.程序刚运行时，如图所示，*s1和 s2不同，while循环不会执行，ptr++指向下一个字符，此时ptr不是’\0’，程序继续执行
3.*s1和 s2不同，重复上述动作
4.当ptr++指向第一个d时，此时s1和 *s2相同，且不为’\0’，while循环执行，让s1++,s2++，并且进行比较，直到比到第三个字符d和e不同，循环中止
5.然后让ptr++指向下一个d，此时s1指向的位置是d,s2指向的位置是e，利用s1=ptr，s2=str2，将s1指向第二个d,str2重新开始，然后再进行比较，最后比较成功，返回ptr的地址
6.while (*s1 && *s2 && (*s1 == *s2))，*s1 && *s2是确保两个字符串在’\0’之前进行寻找

memcpy函数

memcpy函数的介绍

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

参数：destination指向要在其中复制内容的目标数组的指针，类型转换为 void* 类型的指针
source指向要复制的数据源的指针，类型转换为 const void* 类型的指针
num 要拷贝的字节数
返回值：返回目标空间的起始地址
注意：1.这个函数在遇到 ‘\0’ 的时候并不会停下来，它始终精确地复制数字字节
2.为避免溢出，destination和source所指向的数组的大小应至少为 num 个字节，并且不应重叠，（对于重叠的内存块，memmove 是一种更安全的方法）

memcpy函数的使用

int main()
{
	int arr[10] = {1,2,3,4,5,6};
	int arr1[10] = {0};
	int i = 0;
	memcpy(arr1, arr, 20);
	for (i = 0; i < 5; i++)
		printf("%d ", arr1[i]);

	return 0;
}

输出结果：
在这里插入图片描述

准确的将前20个字节的内容拷贝了过去

memcpy函数的模拟实现

#include <stdio.h>
#include <string.h>
#include <assert.h>

void* MyMemcpy(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;
}

int main()
{
	int arr[10] = {1,2,3,4,5,6};
	int arr1[10] = {0};
	int i = 0;
	int* ret=MyMemcpy(arr1, arr, 20);
	for (i = 0; i < 5; i++)
		printf("%d ", ret[i]);

	return 0;
}

1.将memcpy函数的形参全部定为为void*，是因为不知道要处理什么数据，利用void接收参数，最后强制类型转换，再解引用即可
2.对dest和src强制类型转换成char的原因是，在内存中字节是最小的单位，对char*进行解引用可以一次访问一个字节，这样无论是什么数据传进来，都可一个字节一个字节的操作

memmove函数

memmove函数的介绍

void * memmove ( void * destination, const void * source, size_t num )

参数：destination：指向要在其中复制内容的目标数组的指针，类型转换为 void* 类型的指针
source：指向要复制的数据源的指针，类型转换为 const void* 类型的指针
num：要复制的字节数内存块的指针
返回值：返回目标空间的起始地址
注意：1.memcpy与memmove的差别就是memmove函数处理的源内存块和目标空间的内存块是可以重叠的
2.当出现重叠时，需要使用memmove

memmove函数的使用

#include <stdio.h>
#include <string.h>
#include <assert.h>


int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};

	memmove(arr + 2, arr, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
		printf("%d ", arr[i]);//12123458910
	return 0;
}

输出结果：
在这里插入图片描述

将arr前5个元素即20个字节的内容拷贝到从arr[2]开始向后的5个元素

memmove函数的模拟使用

#include <stdio.h>
#include <string.h>
#include <assert.h>

void* MyMemmove(void* dest, void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	if (dest < src)
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return ret;
}

int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};

	MyMemmove(arr + 2, arr, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
		printf("%d ", arr[i]);//12123458910
	return 0;
}

在这里插入图片描述

由于数组不够大，如图所示显示了两种情况，实际有5种
1.dest<src，没有重叠，从src中，前->后 或者 后->前 拷贝都可以
2.dest<src，有重叠部分，从src中，只能由前->后拷贝，反之，前面的数据还没拷贝就被覆盖了
3.dest=src，完全重叠，此时不需要拷贝，直接返回即可
4.dest>src，有重叠部分，从src中，由后->前拷贝
5.dest>src，没有重叠，从src中，前->后 或者 后->前 拷贝都可以
6.总之，当dest<src时，由前->后拷贝
????当dest>src时，由后->前拷贝

memcmp函数

memcmp函数的介绍

int memcmp ( const void * ptr1, const void * ptr2, size_t num )

参数：ptr1和ptr2都是指向内存块的指针，num是要比较的字节数
返回值：ptr1>ptr2：返回>0的数值
????ptr1=ptr2：返回0
????ptr1<ptr2：返回<0的数值
注意：1.将 ptr1 所指向的内存块的前 num 个字节与 ptr2 指向的第一个字节数进行比较，如果它们都匹配，则返回零，或者如果不匹配，则返回与零不同的值，表示哪个值更大
2.与 strcmp 不同，该函数在找到空字符后不会停止比较

memcmp函数的使用

#include <stdio.h>
#include <string.h>
#include <assert.h>

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,2,4,1 };
	
	int ret = memcmp(arr1, arr2, 12);
	printf("%d",ret);
}

输出结果：
在这里插入图片描述

1.该结果说明arr1的前12个字节大小小于第二块内存的前12个字节大小
2.一次比较一个字节
3.很明显橘色框中的数据arr1小于arr2,所以返回-1
在这里插入图片描述

memset函数

memset函数的介绍

void * memset ( void * ptr, int value, size_t num )

参数：ptr：指向要填充的内存块的指针
???value：要设置的值，也可以是字符
???num：要设置的字节数
返回值：若成功开辟内存空间，返回指向函数分配的内存块的指针，若开辟失败，则返回一个空指针NULL，故需要对返回值进行检查
注意：1.该函数是以字节为单位进行初始化的

memset函数的使用

#include <stdio.h>
#include <string.h>
#include <assert.h>



int main()
{
	char arr1[] = "hello world";
	int arr2[10] = { 0 };
	
	memset(arr1,'6', 5);
	memset(arr2, 1, 40);
	printf("%s\n",arr1);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", arr2[i]);
	}
}

输出结果：
在这里插入图片描述

1.没有输出1的原因是，memset操作的是1个字节，即01 01 01……，所以不会打印1
  C++知识库 最新文章
【C++】友元、嵌套类、异常、RTTI、类型转换
通讯录的思路与实现（C语言)
C++PrimerPlus 第七章 函数-C++的编程模块（
Problem C: 算法9-9~9-12：平衡二叉树的基本
MSVC C++ UTF-8编程
C++进阶 多态原理
简单string类c++实现
我的年度总结
【C语言】以深厚地基筑伟岸高楼-基础篇（六
c语言常见错误合集
上一篇文章      下一篇文章      查看所有文章
加:2022-07-20 18:34:21  更:2022-07-20 18:36:34 
 
开发: C++知识库 Java知识库 JavaScript Python PHP知识库 人工智能 区块链 大数据 移动开发 嵌入式 开发工具 数据结构与算法 开发测试 游戏开发 网络协议 系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑 笔记本 显卡 显示器 固态硬盘 硬盘 耳机 手机 iphone vivo oppo 小米 华为 单反 装机 图拉丁

360图书馆 购物 三丰科技 阅读网 日历 万年历 2024年11日历 -2024/11/23 13:38:46-

图片自动播放器
↓图片自动播放器↓ 		TxT小说阅读器
↓语音阅读,小说下载,古典文学↓ 		一键清除垃圾
↓轻轻一点,清除系统垃圾↓ 		图片批量下载器
↓批量下载图片,美女图库↓
  网站联系: qq:121756557 email:121756557@qq.com  IT数码