C语言进阶——字符函数和字符串函数（下）

在前面我们已经学习了strlen、strcpy、strcat、strcmp几个库函数，今天我们继续学习剩余的库函数。

上期链接：

C语言进阶——字符函数和字符串函数（上）_wangjiushun的博客-CSDN博客

目录：

3、长度受限制的字符串函数

        strncpy

        strncat

        strncmp

4、字符串查找

        strstr

        strtok

5、错误信息报告

        strerror

6、字符操作

7、内存操作函数

        memcpy

        memmove

        memset

        memcmp

三、长度受限制的函数字符串

1、 strncpy

函数原型：char* strncpy(char* destination, const char* source, size_t num)；

1、从源字符串拷贝num个字符到目标空间

2、如果源字符串的长度大于num，则只拷贝num个字符，并不会在目标空间后追加‘\0’字符

3、如果源字符串的长度小于num，则拷贝玩源字符串之后（包括‘\0’），在目标空间的后面追加‘\0’，直到num个。

4、源指向的空间与目标空间不能重叠

5、目标空间必须可变

讲解：

（1）strncpy函数的返回类型和参数是怎么设计的？

        strncpy与strcpy相似，只是多了一个参数size_t num，可以自己决定拷贝几个字符源字符串到目标空间中（在决定拷贝几个字符时，我们会考虑目标空间是否足够大），所以相对strcpy函数安全一些。

（2）拷贝num个字符从源字符串到目标空间

        ①如果源字符串长度大于num，则只拷贝num个字符，并不会在目标后追加‘\0’

代码实例：

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

int main()
{
	char arr1[20] = "################";
	char arr2[] = "abcdef";
	//把arr2中的以首字符开始的前3个字符拷贝到arr1中
	strncpy(arr1, arr2, 3);
	printf("%s\n", arr1);
	return 0;
}

        F10调试之后，观察目标空间arr1的内存：

         ②如果源字符串的长度小于num，则拷贝玩源字符串之后（包括‘\0’），在目标空间的后面追加‘\0’，直到num个。

代码实例：

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

int main()
{
	char arr1[20] = "################";
	char arr2[] = "abcdef";
	//把arr2中的以首字符开始的前10个字符拷贝到arr1中
	strncpy(arr1, arr2, 10);
	printf("%s\n", arr1);
	return 0;
}

        F10调试之后，观察目标空间arr1的内存：

 （3）模拟实现strncpy

分析：

        strncpy函数是从源字符串拷贝num个字符到目标空间的，模拟strncpy，那函数的返回类型、参数类型应该一致。

函数体的实现：

        ①定义char* start变量存储目标空间的起始地址；

        ②将源字符串拷贝num个字符到目标空间：

                a. 拷贝源字符串：num <= 源字符串

                b. 判断num是否为0，不为0在目标后追加‘\0’

        ③返回目标空间的起始地址。

代码演示：

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

char* my_strncpy(char* dest, const char* src, size_t num)
{
	//断言指针的有效性
	assert(dest && src);
	//存储目标空间的起始地址
	char* start = dest;
	//将源指向的字符串拷贝num个字符到目标空间
	//①num <= 源字符串，拷贝源字符串
	while (num)//注意num是无符号类型，写成后置--，易错，所以在后面单独成一条语句
	{
		if ((*dest++ = *src++) == '\0')
		{
			break;
		}
		--num;
	}
	//②num > 源字符串，在目标后面追加'\0'，直至拷贝num个字符
	if (num)
	{
		while (--num)
		{
			*dest++ = '\0';
		}
	}
	//返回目标空间起始地址
	return start;
}

int main()
{
	char arr1[10] = "#########";
	char arr2[] = "abcde";
	//从arr2中拷贝3个字符到arr1
	printf("%s\n", my_strncpy(arr1, arr2, 3));
	//从arr2中拷贝8个字符到arr1
	printf("%s\n", my_strncpy(arr1, arr2, 8));
	return 0;
}

        积累：当类型为无符号类型，后置--且为循环条件循环两次是，易错！（后置--，先赋值再-1，可能减到负数，负数在无符号类型下是很大的正数）

2、 strncat

函数原型：char* strncat(char* destination, const char* source, size_t num);

1、从源字符串的第一个字符开始拷贝num个字符到目标空间字符串的尾部，追加完后再外加一个‘\0’字符；（说明：①目标空间的‘\0’被源字符串的第一个字符覆盖②注意只拷贝源字符串‘\0’之前的字符，不拷贝‘\0’）

2、注意：如果源字符串的长度小于num，则只拷贝‘\0’之前的内容；

3、源指向的空间与目标空间不可以重叠；

4、目标空间可变。

讲解：

（1）模拟strncat

分析：

        strncat函数是从源指向的第一个字符开始拷贝num个字符到目标空间字符串的尾部，追加完后再外加终止‘\0’字符，模拟strncat，那函数的返回类型、参数类型应该一致。

函数体的实现：

        ①定义char* start变量存储目标空间的起始地址；

        ②从源字符串开始拷贝num个字符到目标空间的尾部，追加完后在加终止‘\0’字符：

                a. 找到目标空间的终止‘\0’字符

                b. 追加num个字符到目标空间，当满足条件num > 源字符串长度时，则拷贝完源字符串（包括‘\0’）后，直接返回目标空间起始地址

                c. num < 源字符串长度，追加完num个字符后，再外加终止‘\0’字符

                d. 返回目标空间起始地址（num < 源字符串）

代码演示：

//模拟strncat
#include<stdio.h>
#include<assert.h>

char* my_strncat(char* dest, const char* src, size_t num)
{
	//断言指针的有效性
	assert(dest && src);
	//存储目标空间的起始地址
	char* start = dest;
	//追加num个字符到目标空间
	//①找到目标空间的\0
	while (*dest)
	{
		dest++;
	}
	//②追加num个字符到目标空间
	while (num)
	{
		//如果num > 源字符串的长度，则拷贝到\0退出函数
		if ((*dest++ = *src++) == '\0')
		{
			return start;
		}
		num--;
	}
	//num < 源字符串长度，追加完后附加\0
	*dest = '\0';
	return start;
}

int main()
{
	char arr1[10] = "######";
	char arr2[] = "abc";
	printf("%s\n", my_strncat(arr1, arr2, 2));
	return 0;
}

3、 strncmp

函数原型：int strncmp(const char* str1, const char* str2, size_t num)；

1、比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完

2、返回值与strncmp一样

讲解：

（1）模拟strncmp

分析：

        strncmp函数是str1和str2比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完，模拟strncmp，那函数的返回类型、参数类型应该一致。

函数体的实现：

        ①while循环比较num个对应字符：

                a. 当满足情况——比较到不同字符，*str1 > *str2，返回1，*str1 < *str2，返回-1

                b. 当满足情况——一个字符串结束（即相等），返回0

        ②比较完num个字符，均未出现不同字符，即相等，返回0

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

int my_strncmp(const char* str1, const char* str2, size_t num)
{
	//断言指针的有效性
	assert(str1 && str2);
	//比较num个对应字符的ASCII值
	while (num)
	{
		//①比较到不同的字符
		if (*str1 != *str2)
		{
			//如果str1 > str2,返回1，否则返回-1
			if (*str1 > *str2)
			{
				return 1;
			}
			else
			{
				return -1;
			}
		}
		//②一个字符串结束，返回0
		if (*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
		--num;
	}
	//比较完num个字符，均相同，返回0
	return 0;
}

int main()
{
	char arr1[] = "abcqw";
	char arr2[] = "abcaw";
	int ret = my_strncmp(arr1, arr2, 4);
	if (ret > 0)
	{
		printf("arr1 > arr2\n");
	}
	else if (ret == 0)
	{
		printf("arr1 = arr2\n");
	}
	else
	{
		printf("arr1 < arr2\n");
	}
	return 0;
}

四、字符串查找

1、 strstr

函数原型：char* strstr(const char* str1, const char* str2);

1、strstr函数查找子字符串；

2、在str1中找str2中第一次出现的位置，如果找到返回一个指针，指向str2在str1中第一次出现的位置；如果找不到（即str2不是str1的子集），就返回一个NULL指针。

讲解：

（1）代码演示：strstr

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

int main()
{
	char str[] = "This is a simple string";
	//接收strstr的返回值
	char* pch;
	//将str字符串中的simple子串修改为sample
	//①得到子串在str中第一次出现的位置
	pch = strstr(str, "simple");
	if (pch != NULL)
	{
		//②将sample拷贝到子串的位置
		strncpy(pch, "sample", 6);
		//输出修改后的str
		puts(str);
	}
	else
	{
		printf("str中子串不存在\n");
	}
	return 0;
}

（2）模拟strstr

分析：

        strstr函数是查找字符串，判断str2是否为str1的子集，是则返回str1中str2第一次出现得我位置，否则返回NULL。

函数体的实现：

        ①特殊情况：str为‘\0’是，直接返回str1（“特事特办”）

        ②遍历str1，当满足情况str2是str1的子集或str1结束：

              a. cp指针用来遍历str1，给s1赋值；

              b. c. s1指针用来每次判断该位置是否为str1中子集str2的位置，不是则str1遍历；

               c.  s2指针用来遍历str2是否与s1相等，相等则返回s1的起始地址（即cp），不相等则重新回到str2的位置;

代码演示：

//模拟strstr
/*
	分析：strstr函数查找子字符串，判断str2是否为str1的子集。是则返回子字符串的位置，否则返回NULL
*/
#include<stdio.h>
#include<assert.h>

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	//特殊情况：str2为'\0'时，直接返回str1
	if (*str2 == '\0')
	{
		return (char*)str1;
	}
	//s1用于从主字符串的第一个字符开始遍历主字符串是否包含子串，
	//遍历到不同于子串的字符，又从主字符串的第二个字符开始遍历;
	//直至遍历到包含，或遍历到主字符串的\0
	const char* s1 = NULL;
	//s2每一次新遍历时都会重新回到str2的位置
	const char* s2 = NULL;
	//存放子串可能的位置，从主字符串的首字符开始
	const char* cp = str1;
	while (*cp)
	{
		s1 = cp;
		s2 = str2;
		while (*s1 != '\0' && *s2 != '\0' && * s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return (char*)cp;
		}
		else if (*s1 == '\0')
		{
			return NULL;
		}
		cp++;
	}
	return NULL;
}

int main()
{
	char arr1[] = "abbcdbba";
	char* ret = my_strstr(arr1, "bbbd");
	if (ret != NULL)
	{
		printf("%s\n", ret);
	}
	else
	{
		printf("没有找到\n");
	}
	return 0;
}

2、 strtok

函数原型：char* strtok(char* str,const char* sep);

1、sep参数是个字符串，定义了用作分隔符的字符集合；

2、第一个参数指定一个字符串，它包含了0个或多个由sep字符串中一个或者多个分隔符分割的标记；

3、strtok函数找到str中的下一个标记，并将其用‘\0’结尾，返回一个指向这个标记的指针（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）；

4、strtok函数的第一个参数不为NULL，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置；

5、strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记；

6、如果字符串不存在更多的标记，则返回NULL指针。

代码演示：

代码1：

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

int main()
{
	char arr[] = "2809552931@qq.com";
	//分割邮箱
	//2809552931  qq  com
	//分割符集合：@.
	char* sep = "@.";
	//注意：strtok函数会改变被操作的字符串，所以在使用strtok分割的字符串
	//一般都是临时拷贝的内容并且可修改。
	char arr1[20];
	strcpy(arr1, arr);
	//strtok函数找到arr中的标记，并将其用\0结尾，返回一个指向这个标记的指针
	//①strtok函数的第一个参数不为NULL，函数将找到arr1中第一个标记，
	//strtok函数将保存它在字符串中的位置
	char* ret = strtok(arr1, sep);
	printf("%s\n", ret);
	//②strtok函数的第一个参数为NULL，函数将在同一个字符串中
	//被保存的位置开始，开始查找下一个标记
	ret = strtok(NULL, sep);
	printf("%s\n", ret);
	//③如果字符串不存在更多的标记，则返回NULL指针
	ret = strtok(NULL, sep);
	printf("%s\n", ret);
	return 0;
}

代码2：

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

int main()
{
	char arr[] = "2809552931@qq.com";
	//分割邮箱
	//2809552931  qq  com
	//分割符集合：@.
	char* sep = "@.";
	//注意：strtok函数会改变被操作的字符串，所以在使用strtok分割的字符串
	//一般都是临时拷贝的内容并且可修改。
	char arr1[20];
	strcpy(arr1, arr);
	char* ret = NULL;
	//strtok函数：除第一次调用，其余调用都是传null，这样才会继续向后寻找分隔符
	for (ret = strtok(arr1, sep); ret != NULL; ret = strtok(NULL, sep))
	{
		printf("%s\n", ret);
	}
	return 0;
}

五、错误信息报告

1、strerror

头文件：“string.h”

函数原型：char* strerror(int errnum);

1、返回错误码，所对应的错误信息

2、注意：要配合printf才能打印出错误信息。

讲解：

（1）函数的返回类型和参数：

        返回类型：char* ——字符指针，指向错误码所对应的错误信息的字符串首字符地址

        参数：int ——错误码是一些整数

（2）返回错误码，所对应的错误信息

        C语言的库函数在调用的时候，如果发生错误，就会将错误码存在一个变量中，这个变量是：errno（头文件：“errno.h”）。

        错误码是一些数字：0 1 2 3 4 5

        每一个错误码都对应一个错误信息。

代码演示：

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

int main()
{
	printf("%s\n", strerror(0));
	printf("%s\n", strerror(1));
	printf("%s\n", strerror(2));
	printf("%s\n", strerror(3));
	printf("%s\n", strerror(4));
	printf("%s\n", strerror(5));

	return 0;
}

        运行结果：

（3）strerror的正确使用：

        当C语言的库函数调用时发生错误，会将错误码存放在（全局）变量errno中，使用strerror可以获得错误码所对应的错误信息的字符串首地址，配合printf将错误码打印出来。

 代码示例：如打开文件失败，想知道为什么打开失败

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

int main()
{
	//打开文件
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//读文件
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

         运行结果：

2、perror

头文件：“stdio.h”

函数原型：void perror（const char* str）；

1、直接打印错误信息，在打印错误信息前，会先打印自定义的信息。

2、可理解为：perror = printf + strerror

讲解：

（1）函数的返回类型和参数：

        返回类型：void —— 没有返回值

        参数：C字符串，包含要在错误信息本身之前打印的自定义信息。如果是NULL，则不会打印前面的自定义信息，但仍会打印错误信息。按照惯例，应用程序本身的名称通常用作参数。

（2）代码演示：如打开文件失败，想知道为什么打开失败

#include<stdio.h>

int main()
{
	//打开文件
	//‘r’——打开方式：只读（如果该文件路径下，没有该文件则读取失败）
	FILE* pf = fopen("test.txt", "r");
	//如果文件打开失败，打印失败原因
	if (NULL == pf)
	{
		perror("fopen");
		return 1;
	}
	//读文件
	//关闭文件
	fclose(pf);
	pf = NULL;
	return 0;
}

        运行结果：

六、字符操作

1、字符分类函数：（头文件：“ctype.h”）

函数如果他的参数符合下列条件就返回真
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任何可打印字符，包括图形字符和空白字符

代码演示：islower

#include<stdio.h>
#include<ctype.h>

int main()
{
	char ch = 0;
	//多组输入，判断输入值是否为小写字母
	while ((scanf("%c", &ch)) != EOF)
	{
		//islower函数判断它的参数是否为小写字母
		//是小写字母，为真返回非零的数字
		//不是小写字母，为假返回0
		printf("%d\n", islower(ch));
		//清空缓存区
		getchar();
	}
	return 0;
}

        运行结果：

2、字符转换

头文件：ctype.h

1、大写转小写

int tolower(int c);

2、小写转大写

int toupper(int c);

代码演示：

代码1：

#include<stdio.h>
#include<ctype.h>

int main()
{
	//大写字母转小写字母
	printf("%c\n", tolower('A'));
	//小写字母转大写字母
	printf("%c\n", toupper('b'));
	return 0;
}

        运行结果：

        代码2：将字符串中的小写字母转换为大写字母

#include<stdio.h>
#include<ctype.h>

int main()
{
	char arr[] = "I Have An Apple.";
	int i = 0;
	while (arr[i])
	{
		//如果为小写字母转换为大写字母
		if (islower(arr[i]))
		{
			arr[i] = toupper(arr[i]);
		}
		printf("%c", arr[i]);
		i++;
	}
	return 0;
}

        运行结果：

七、内存操作函数

        之前我们学习的库函数只能操作字符串函数，那我们要操作其他类型的数组该怎么办呢？

        答案是：内存操作函数。

1、memcpy

函数原型：void* memcpy(void* destination, const void* source, size_t num);

1、函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存空间；

2、这个函数在遇到‘\0’的时候并不会停下来；

3、如果source和destination有任何的重叠，复制的结果都是未定义的。（在VS的平台上memcpy进行了优化与memmove一样，但是不保证所有平台都进行优化）

讲解：

（1）函数的返回类型和参数：

        返回类型：void* —— 指向目标空间的起始地址

        参数：①void* dest —— 不知道是指向什么类型地址

                   ②const char* src —— 不知道是指向什么类型地址，且源指向的内容不变

                    ③size_t num —— 拷贝的字节数

（2）如果source和destination有任何的重叠，复制的结果都是未定义的。（在VS的平台上memcpy进行了优化与memmove一样，但是不保证所有平台都进行优化）

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

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//将arr1中的1,2,3,4,5拷贝到arr1+2中
	memcpy(arr1 + 2, arr1 , 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

        图示：

        （3）模拟实现memcpy

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

void* my_memcpy(void* dest, const void* src, size_t num)
{
	//断言指针的有效性
	assert(dest && src);
	//存储目标空间的起始地址
	void* ret = dest;
	//从src指向的位置拷贝num个字节的数据到dest
	//void* 不能直接使用，必须转化为确定的类型才能使用
	while (num)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
		--num;
	}
	return ret;
}

int main()
{
	int arr1[10] = { 0 };
	int arr2[10] = { 1,2,3,4,5,6,7,8 };
	//将arr2中的3,4,5,6,7拷贝到arr1中
	my_memcpy(arr1, arr2+2, 20);
	//打印arr1
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

2、memmove

函数原型：void* memmove(void* destination, const void* source, size_t num);

1、和memcpy的差别就是memmove函数处理的源内存块和目标空间内存块是可以重叠的；

2、如果源空间和目标空间出现重叠，就得使用memmove函数处理。

讲解：

（1）模拟memmove

分析：

        memmove函数是实现源指向的内容拷贝到目标空间，源空间和目标空间可以重叠。

函数体实现：（如图）

        代码演示：

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

void* my_memmove(void* dest, const 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 + num) = *((char*)src + num);
		}
	}

	return ret;
}


int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//将arr1中的1,2,3,4,5拷贝到arr1+2中
	my_memmove(arr1 + 2, arr1 , 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

3、memcmp

函数原型：int memcmp（const void* ptr1，const void* ptr2，size_t num）；

①比较从ptr1和ptr2指针开始的num个字节、

②标准规定：

        ptr1 > ptr2,返回正数

        ptr1 = ptr2，返回零

        ptr1 < ptr2，返回负数

代码演示：

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

int main()
{
	int arr1[] = { 1,2,3 };
	//VS——小端存储：低位存放低地址
	//0x:01 00 00 00 02 00 00 00 03 00 00 00
	int arr2[] = { 1,2,5 };
	//0x:01 00 00 00 02 00 00 00 05 00 00 00
	//比较整形数组，从arr1和arr2开始的9个字节
	int ret = memcmp(arr1, arr2, 9);
	printf("%d\n", ret);
	return 0;
}

        运行结果：

4、memset

函数原型：void* memset(void* ptr,int value,size_t num);

1、以字节为单位来设置内存中的数据；

2、填充内存块，将某一块内存中的内容全部设置为指定的值， 通常为新申请内存做初始化工作。

讲解：

（1）函数返回类型和参数：

        返回类型：void* ——返回ptr指向的地址

        参数：①void* ptr —— 指向要填充内存块的指针（因为不知道类型，所以设为空指针）

                   ②int value —— 要设置的值（为整形家族的值且要注意不要太大，因为是以字节为单位来填充内存的）

                   ③size_t num —— 去设置填充的字节数（因为不知道是什么类型）

代码演示：

代码1：可以使用memset把整形数组初始化为1吗

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

int main()
{
	int arr[5] = { 1,2,3,4,5 };
	memset(arr, 1, 20);
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

        运行结果：

        我们发现结果和我们预期结果不同，因为memset函数是以字节为单位来设置内存中的数据的。

        我们F10调试起来，观察arr内存

  

        代码2：

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

int main()
{
	char arr[] = "hello world";
	//将arr中的world改为yyyyy
	memset(arr + 6, 'y', 5);
	printf("%s\n", arr);
	//将arr中的hello改为xxxxx
	memset(arr, 'x', 5);
	printf("%s\n", arr);
	return 0;
}

        运行结果：

 字符串函数、内存函数就完结了，希望对大家有帮助。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/23657.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

不愧是字节出来的，太厉害了...

不愧是字节出来的，太厉害了...

前段时间公司缺人&#xff0c;也面了许多测试&#xff0c;一开始瞄准的就是中级水准&#xff0c;当然也没指望能来大牛&#xff0c;提供的薪资在15-20k这个范围&#xff0c;来面试的人有很多&#xff0c;但是平均水平真的让人很失望。看了简历很多上面都是写有4年工作经验&…
阅读更多...
文件包含的本质、预处理符号、# vs ##

文件包含的本质、预处理符号、# vs ##

何为头文件&#xff1f; 在C语言中&#xff0c;文件包含是一种常见的编程技术&#xff0c;它允许程序员在一个源文件中使用另一个源文件中的函数或变量。 文件包含通常使用#include预处理指令来实现。#include指令告诉预处理器将文件的内容插入到当前文件的指定位置中。 例如&a…
阅读更多...
python学习-基础知识总结

python学习-基础知识总结

&#xff08;一&#xff09;基础语法 1.1、注释 程序添加注释&#xff0c;可以用来解释程序某些部分的作用和功能&#xff0c;提高程序的可读性&#xff0c;注释有两种形式&#xff1a; 单行注释&#xff1a;#多行注释&#xff1a;单引号&#xff08;注释内容&#xff09;或双…
阅读更多...
笔试强训 Day6

笔试强训 Day6

选择题 1.十进制变量i的值为100&#xff0c;那么八进制的变量i的值为&#xff08;&#xff09; A 146 B 148C 144 D 142 本题很简单&#xff1a;100除8&#xff0c;取余数&#xff0c;直到商为零&#xff0c;最后反向的串起余数即可 2.执行下面语句后的输出为&#xff08;&…
阅读更多...
【Python从入门到进阶】21、爬虫相关概念介绍

【Python从入门到进阶】21、爬虫相关概念介绍

接上篇《20、HTML页面结构的介绍》 上一篇我们正式进入了Python爬虫的实战教程&#xff0c;主要讲解了要爬取的HTML页面的结构。本篇我们来介绍爬虫的相关概念。 一、什么是互联网爬虫 如果我们把互联网比作一张大的蜘蛛网&#xff0c;那一台计算机上的数据便是蜘蛛网上的一个…
阅读更多...
unity制作一款塔防游戏

unity制作一款塔防游戏

文章目录 介绍寻路系统怪物生成器制作3种初级炮台、3种升级炮台设置炮台属性选择炮台&#xff0c;添加监听事件炮弹追踪攻击敌人拖动鼠标实现相机视角转换鼠标光标放在cube上变色文字动画 介绍 关键技术&#xff1a; 寻路系统 生成怪物算法 粒子系统 line renderer制作追踪射线…
阅读更多...
通过Python的pdfplumber库提取pdf中表格数据

通过Python的pdfplumber库提取pdf中表格数据

文章目录 前言一、pdfplumber库是什么&#xff1f;二、安装pdfplumber库三、查看pdfplumber库版本四、提取pdf中表格数据1.引入库2.定义pdf文件路径3.打开pdf文件4.获取pdf文件中的页数5.遍历每一页6.获取当前页内容7.提取表格数据8.输出表格数据9.效果 总结 前言 大家好&#…
阅读更多...
Scala学习(九)---List集合

Scala学习(九)---List集合

文章目录 1.List1.1 不可变List集合1.2 可变集合ListBuffer 1.List List集合默认为不可变集合&#xff0c;List集合在实例化的时候&#xff0c;无法通过new关键字进行实例化&#xff0c;只能通过伴生apply方法来对其进行实例化 1.1 不可变List集合 创建一个不可变list集合 …
阅读更多...
HUD（抬头显示）的方案介绍

HUD（抬头显示）的方案介绍

目录 一、基于DLP3030-Q1的HUD电路设计 二、DLP3030-Q1的介绍 三、DLP3030-Q1工作原理 四、DLPC120-Q1DMD 显示控制器 五、TMS320F2802332 位 MCU 六、 HUD显示实例 HUD主板实例 七、HUD的软件环境 一、基于DLP3030-Q1的HUD电路设计 本设计采用了DLP3030-Q1 芯片组&…
阅读更多...
设计模式 -第1部分 避免浪费- 第1章 Flyweight 模式 - 共享对象避免浪费

设计模式 -第1部分 避免浪费- 第1章 Flyweight 模式 - 共享对象避免浪费

第1部分 避免浪费 注&#xff1a;其内容主要来自于【日】-结城浩 著《图解设计模式》20章节 极力推荐大家阅读原著 第1章 Flyweight 模式 - 共享对象避免浪费 1.1 Flyweight 模式 Flyweight 的意思"轻量级"&#xff0c;其在英文中的原意指比赛中选手体重最轻等级的一…
阅读更多...
【C语言】实现猜数字游戏——随机数

【C语言】实现猜数字游戏——随机数

&#x1f6a9;纸上得来终觉浅&#xff0c; 绝知此事要躬行。 &#x1f31f;主页&#xff1a;June-Frost &#x1f680;专栏&#xff1a;C语言 该篇将对 选择与循环语句 进行运用&#xff0c;实现猜数字游戏。 需求&#xff1a;游戏后可以选择再次进行游戏&#xff0c;也可以选择…
阅读更多...
「实在RPA·烟草数字员工」助力烟草行业数字化转型加速度

「实在RPA·烟草数字员工」助力烟草行业数字化转型加速度

烟草行业作为烟草产业链上重要一环&#xff0c;外部连接烟草工业企业、零售客户、消费者&#xff0c;内部包含营销、专卖、烟叶、物流等诸多业务&#xff0c;信息系统众多&#xff0c;企业数据量庞大。因此&#xff0c;清楚地了解自身存在的痛点&#xff0c;找到适合自身业务需…
阅读更多...
如何在华为OD机试中获得满分？Java实现【寻找峰值】一文详解！

如何在华为OD机试中获得满分？Java实现【寻找峰值】一文详解！

✅创作者&#xff1a;陈书予 &#x1f389;个人主页&#xff1a;陈书予的个人主页 &#x1f341;陈书予的个人社区&#xff0c;欢迎你的加入: 陈书予的社区 &#x1f31f;专栏地址: Java华为OD机试真题&#xff08;2022&2023) 文章目录 1. 题目描述2. 输入描述3. 输出描述…
阅读更多...
gitbook在centos上安装

gitbook在centos上安装

1&#xff09;官网下载Node.js的Linux64位的二进制包:Download | Node.js 或者在线下载&#xff1a; wget https://nodejs.org/dist/v12.16.1/node-v12.16.1-linux-x64.tar.xz ​​2)到指定目录​解压 cd /opt/gitbook tar -xJf node-v12.16.1-linux-x64.tar.xz mv node-…
阅读更多...
STM32采集传感器数据通过排序取稳定值

STM32采集传感器数据通过排序取稳定值

一、前言 在物联网、单片机开发中，经常需要采集各种传感器的数据。比如：温度、湿度、MQ2、MQ3、MQ4等等传感器数据。这些数据采集过程中可能有波动，偶尔不稳定，为了得到稳定的值，我们可以对数据多次采集，进行排序，去掉最大和最小的值，然后取平均值返回。 二、排序算法…
阅读更多...
运维工程师面试总结(含答案)

运维工程师面试总结(含答案)

运维工程师面试总结 原文链接&#xff1a;https://www.cuiliangblog.cn/detail/article/2 一、linux 1. linux系统启动流程 第一步&#xff1a;开机自检&#xff0c;加载BIOS第二步&#xff1a;读取&#xff2d;&#xff22;&#xff32;第三步&#xff1a;Boot Loader　grub…
阅读更多...
华为OD机试之真正的密码（Java源码）

华为OD机试之真正的密码（Java源码）

真正的密码 题目描述 一行中输入一个字符串数组&#xff0c;如果其中一个字符串的所有以索引0开头的子串在数组中都有&#xff0c;那么这个字符串就是潜在密码在所有潜在密码中最长的是真正的密码&#xff0c;如果有多个长度相同的真正的密码&#xff0c;那么取字典序最大的为…
阅读更多...
【ClickHouse】

【ClickHouse】

文章目录 一、表引擎1、表引擎的作用2、TinyLog3、Memory4、MergeTree二、数据库引擎1、作用--跨种类交换数据2、示例 三、MergeTree引擎1、简单使用2、分区partition by3、主键primary key4、order by&#xff08;必填&#xff09; 一、表引擎 1、表引擎的作用 CK表引擎决定…
阅读更多...
智能运维应用之道，告别企业数字化转型危机

智能运维应用之道，告别企业数字化转型危机

面临的问题及挑战 数据中心发展历程 2000 年中国数据中心始建&#xff0c;至今已经历以下 3 大阶段。早期&#xff1a;离散型数据中心 IT 因以项目建设为导向&#xff0c;故缺乏规划且无专门运维管理体系&#xff0c;此外&#xff0c;开发建设完的项目均是独立运维维护&#…
阅读更多...
【喜闻乐见，包教包会】二分图最大匹配:匈牙利算法（洛谷P3386）

【喜闻乐见，包教包会】二分图最大匹配:匈牙利算法（洛谷P3386）

&#x1f3ad;不要管上面那玩意。。。 引入 现在&#xff0c;你&#xff0c;是一位酒店的经理。 西装笔挺&#xff0c;清瘦智慧。 金丝眼镜&#xff0c;黑色钢笔。 大理石的地板&#xff0c;黑晶石的办公桌&#xff0c;晶莹的落地玻璃。 而现在&#xff0c;有几个雍容华贵的…
阅读更多...
最新文章

Copyright @ 2022~2023