字符以及字符串函数

字符以及字符串函数

  • 求字符串长度
    • strlen
  • 长度不受限制的字符串函数
    • strcpy
    • strcat
    • strcmp
  • 长度受限制的字符串函数
    • strncpy
    • strncat
    • strncmp
  • 字符串查找
    • strstr
    • strtok
  • 错误信息报告
    • strerror
  • 字符分类函数
  • 字符转换函数
    • tolower
    • toupper
  • 内存操作函数
    • memcpy
    • memmove
    • memcmp
    • memset

这篇文章注意讲述了库函数中常见字符函数以及字符串函数的使用，以及注意事项，同时模拟实现部分函数.本文主要使用网站链接: cplusplus

求字符串长度

strlen

stelen

  • strlen介绍

size_t strlen(const char* str);

获取字符串长度：C 字符串的长度由终止 null 字符决定：C 字符串的长度与字符串开头和终止 null 字符之间的字符数（不包括终止 null 字符本身）一样长。

  • 头文件：#include<string.h>
  • 参数：字符串
  • 返回值：字符串的长度

注意事项：
1.strlen 是求字符串长度的，求出的长度不可以为负，所以返回类型为size_t，是无符号的（size_t可以看作是umsigned int 类型，但俩者不同之处在于俩个size_t的返回值相减得到的值任然是size_t）
2.字符串已经将’\0’作为结束标志，strlen函数返回的是在字符串中’\0’前面出现的字符个数（不包含’\0’）
3.参数指向的字符串必须要以’\0’为结束标准

  • 实际使用：
//strlen的实际使用
#include<stdio.h>
#include<string.h>
int main(void)
{char arr[] = "hello!";int ret1 = (int)strlen(arr);printf("%d\n", ret1);printf("%d\n", (int)strlen("future"));return 0;
}
  • 运行截图：
    stlen
  • 模拟实现：
    方法1：使用计数器模拟实现strlen
#include<stdio.h>
#include<assert.h>
//使用计数器模拟实现strlen
size_t my_strlen(const char* str)
{//断言：字符串不能为空assert(str);int count = 0;while (*str){count++;str++;}return count;
}
int main(void)
{char arr[] = "Hello China!";//接收字符串长度int ret = (int)my_strlen(arr);//打印printf("%d ",ret);return 0;
}

方法2：使用递归模拟实现strlen

//使用递归模拟实现strlen
#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{//断言：字符串不能为空assert(str);if (*str=='\0'){return 0;}else{return 1 + my_strlen(str+1);}
}
int main(void)
{char arr[] = "Hello beijing!";//接收字符串长度int ret = (int)my_strlen(arr);//打印printf("%d", ret);return 0;
}

方法3：使用指针与指针之间的运算模拟实现strlen

#define  _CRT_SECURE_NO_WARNINGS 1	
//使用指针与指针之间的运算模拟实现strlen
#include<stdio.h>
size_t my_strlen(const char* str)
{char* s = str;while (*s !='\0'){s++;}return s - str;
}
int main(void)
{char arr[] = "Hello shandong！";//接收返回值int ret = (int)my_strlen(arr);//打印printf("%d", ret);return 0;
}

长度不受限制的字符串函数

strcpy

strcpy

  • strcpy介绍

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

拷贝字符串：将源指向的 C 字符串复制到目标指向的数组中，包括终止 null 字符（并在该点停止）

  • 头文件：#include<string.h>
  • 参数destination：指向要复制内容的目标数组的指针
  • 参数source：要复制的 C 字符串
  • 返回值：返回目标数组起始的指针

注意事项：
1.源字符串必须以’\0’结束
2.会将源字符串中的’\0’拷贝到目标空间
3.目标空间必须足够大，以确保能存放源字符串
4.目标空间可变

  • 实际使用：
//strcpy的实际使用
#include<stdio.h>
#include<string.h>
int main(void)
{char destination[20] = { 0 };char source[] = "Hello shanxi!";//拷贝字符串strcpy(destination,source);//打印destinationprintf("%s\n",destination);return 0;
}
  • 运行截图：

strcpy

  • 模拟实现
//模拟实现strcpy
#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{//断言assert(dest && src);//定义一个返回值char* ret = dest;while (*src != '\0'){*dest++ = *src++;}return ret;
}
int main(void)
{//destination数组char dest[30] = { 0 };//source数组char src[] = "Hello neimenggu!";//模拟实现strcpymy_strcpy(dest, src);//打印printf("%s",dest);return 0;
}

strcat

strcat

  • strcat介绍

char* strcat(char* destinaion,char* source)

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

  • 头文件：#include<stdio.h>
  • 参数desitination：指向目标数组的指针，该数组应包含 C 字符串，并且足够大以包含连接的结果字符串
  • 参数source：要附加的 C 字符串。这不应与目标重叠
  • 返回值：目标数组的地址

注意事项：
1.源字符串必须以’\0’结束
2.目标空间必须足够大，能容纳下源字符串的内容
3.目标空间必须可以被修改
4.源字符串和目标空间相同时，可能会出现问题，不建议使用strcat

  • 实际使用：
//实际使用strcat
#include<stdio.h>
//头文件
#include<string.h>int main(void)
{char dest[20] = "Hello ";char src[] = "gansu！";//使用strcatstrcat(dest, src);//打印printf("%s", dest);return 0;
}
  • 运行截图：
    strcat
  • 模拟实现：
//strcat模拟实现
#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{assert(dest && src);//将dest的起始位置保存char ret = dest;//将dest循环至\0while (*dest != '\0'){dest++;}//将src字符串连接在dest后面while (*src != '\0'){*dest = *src;dest++;src++;}return ret;
}int main(void)
{char dest[30] = "Hello ";char src[] = "heilongjiang!";//模拟实现strcatmy_strcat(dest, src);//打印printf("%s", dest);return 0;
}

strcmp

strcmp

  • strcmp介绍：

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

比较俩个字符串:此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续执行以下对，直到字符不同或达到终止 null 字符.此函数执行字符的二进制比较。

  • 头文件:#include<string.h>
  • 参数:被比较的字符串
  • 返回值:返回一个整数值，该值指示字符串之间的关系:
返回值表明
<0第一个字符串小于第二字符串
0第一个字符串等于第二个字符串
>0第一个字符串大于第二个字符串

注意事项:
1.比较俩个字符串时比较俩个字符串对应位置的ASCII码值(将其转换为2进制比较)
2.在vs环境下返回>0,=0,<0的值

  • 实际使用:
//strcmp的实际使用
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{//俩个不相等的字符串char str1[] = "Hello!";char str2[] = "hello!";//俩个相等的字符串char str3[] = "liaoning";char str4[] = "liaoning";//比较1和2int ret1 = strcmp(str1, str2);//打印printf("%d\n",ret1);//比较3和4int ret2 = strcmp(str3, str4);//打印printf("%d\n", ret2);return 0;
}

  • 运行结果:
    strcmp

  • 模拟实现:

#define  _CRT_SECURE_NO_WARNINGS 1	
//strcmp的模式实现
#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* str1, const char* str2)
{//断言assert(str1 && str2);int cmp = 0;//循环相同的字符while (*str1 ==*str2){if (*str1 == '\0'){return 0;}str1++;str2--;}//比较不同的字符if (*str1 > *str2){return 1;}else{return -1;}
}
int main(void)
{char str1[] = "Hello Tianjin！";char str2[] = "Hello tianjin！";//模拟实现strcmpint ret = my_strcmp(str1, str2);//打印printf("%d", ret);return 0;
}

长度受限制的字符串函数

strncpy

strncpy

  • strncpy介绍:

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

从字符串中复制字符:将源的前 num 个字符复制到目标。如果在复制 num 个字符之前找到源 C 字符串的末尾（由 null 字符表示），则 destination 将用零填充，直到将 num 个字符写入该字符串。

  • 头文件:#include<string.h>
  • 参数destination:指向要复制内容的目标数组的指针
  • 参数source:要复制的 C 字符串
  • 参数num:要从源复制的最大字符数(size_t 是无符号整数类型)
  • 返回值:返回目标数组起始的指针

注意事项:
1.如果 source 的长度大于 num，则不会在目标末尾隐式附加 null 字符。因此，在这种情况下，destination 不应被视为以 null 结尾的 C 字符串(这样读取它会溢出)
2.目的地和源不得重叠
3.如果源字符串的长度小于num,则拷贝完字符串之后,在目标的后面追加0,直到num个

  • 实际使用:
#define  _CRT_SECURE_NO_WARNINGS 1	
//实际使用strncpy
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{char destination[20] = "***************";char source[] = "Hello hebei!";//从字符串中复制字符strncpy(destination, source, 12);//打印printf("%s", destination);return 0;
}

  • 运行结果:
    strcvpy

  • 模拟实现:

//模拟实现strncpy
#include<stdio.h>
#include<assert.h>
char* my_strncpy(char* destination, const char* source, int num)
{assert(destination && source);char* ret = destination;int i = 0;while(num--){*destination = *source;destination++;source++;}return ret;
}
int main(void)
{char dest[] = "***************";char src[] = "Hello jilin!";//模拟实现strncpymy_strncpy(dest, src, 12);//打印printf("%s", dest);return 0;
}

strncat

strncat

  • strncat介绍:

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

从字符串中附加字符:将源的前 num 字符追加到 destination 后，加上一个终止的 null 字符。

  • 头文件:#include<string.h>
  • 参数destination:指向目标数组的指针
  • 参数source:要附加的 C 字符串
  • 参数num:要追加的最大字符数(size_t 是无符号整数类型)

注意事项:
1.如果源代码中 C 字符串的长度小于 num，则仅复制终止 null 字符之前的内容
2.目标数组应包含 C 字符串，并且足够大以包含连接的结果字符串，包括其他 null 字符

  • 实际使用:
//实际使用strncat
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{char dest[30] = "Hello ";char src[] = "xinjiang!";//使用strncatstrncat(dest,src,3);//打印printf("%s",dest);return 0;
}
  • 运行截图:

strncat

  • 模拟实现:
//模拟实现strncap
#include<stdio.h>
#include<assert.h>
char* my_strncat(char* dest, const char* src, int num)
{assert(dest && src);char* ret = dest;//循环dest至结束while (*dest){dest++;}//连接字符串while (num--){*dest = *src;dest++;src++;}return ret;
}
int main(void)
{char dest[30] = "Hello ";char src[] = "xizang!";//模拟实现strncapmy_strncat(dest, src, 2);;//打印printf("%s",dest);return 0;
}

strncmp

strncmp

  • 介绍strncmp:

int strncmp (const char* str1,const char* str2);

比较两个字符串的字符:将 C 字符串 str1 的字符数与 C 字符串 str2 的字符数进行比较。

  • 头文件:#include<string.h>
  • 参数str1:要比较的 C 字符串
  • 参数str2:要比较的 C 字符串
  • 参数num:要从源复制的最大字符数(size_t 是无符号整数类型)
  • 返回值:返回一个整数值，该值指示字符串之间的关系:
返回值表明
<0第一个字符串小于第二字符串
0第一个字符串等于第二个字符串
>0第一个字符串大于第二个字符串

注意事项:
1.此函数开始比较每个字符串的第一个字符。
2.如果它们彼此相等，则继续执行以下对，直到字符不同，直到达到终止的 null 字符，或者直到两个字符串中的 num 个字符匹配，以先发生者为准

  • 实际使用:
//实际使用strncmp
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{char str1[] = "Hello Qinghai!";char str2[] = "Hello qinghai!";//比较字符串int ret = strncmp(str1,str2,10);//打印printf("%d",ret);return 0;
}
  • 运行结果:

\strcmp

  • 模拟实现:
//模拟实现strncmp
#include<stdio.h>
#include<assert.h>
int my_strncmp(const char* str1, const char* str2, int num)
{assert(str1 && str2);while (*str1 == *str2 && num){if (*str1 == '\0'||num==0){return 0;}str1++;str2++;num--;}if (*str1 > *str2){return 1;}elsereturn -1;
}
int main(void)
{char str1[] = "Hello Sichuan!";char str2[] = "Hello sichuan!";//模拟实现比较字符串int ret = my_strncmp(str1, str2, 10);//打印printf("%d",ret);return 0;
}

字符串查找

strstr

strstr

  • strstr介绍：

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

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

查找子字符串：返回指向 str1 中首次出现的 str2 的指针，如果 str2 不是 str1 的一部分，则返回空指针

  • 头文件：#include<string.h>
  • 参数str1：要扫描的 C 字符串
  • 参数str2：包含要匹配的字符序列的 C 字符串
  • 返回值：指向 str1 中指定的整个字符序列在 str1 中首次出现的指针，如果序列在 str1 中不存在，则为空指针

注意事项：
1.匹配过程不包括终止 null 字符

  • 实际使用：
//实际使用strstr
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{char str1[] = "Hello yunnan!";char str2[] = "yunnan";//查找子字符串char* ret = strstr(str1, str2);//打印printf("%s",ret);return 0;
}
  • 运行结果：

strstr

  • 模拟实现：
//strstr模拟实现
#include<stdio.h>
#include<assert.h>
const char* my_strstr(const char* str1, const char* str2)
{assert(str1 && str2);while (*str1!='\0'){//引用俩个指针代替str1,str2char* S1 = str1;char* S2 = str2;//代替指针进入比较循环while (*S1 == *S2&&*S1!='\0' && *S2 != '\0'){S1++;S2++;}if (*S2 == '\0'){return str1;}str1++;}return NULL;
}
int main(void)
{char str1[] = "Hello hainan!";char str2[] = "hainan";//模拟实现strstrchar* ret = my_strstr(str1, str2);//打印printf("%s",ret);return 0;
}

strtok

strtok

  • 介绍strtok：

char* strtok(char* str,const char* delimiters)

将字符串拆分：对此函数的一系列调用将 str 拆分为标记，这些标记是由分隔符中的任何字符分隔的连续字符序列。

  • 头文件：#include<stdio,h>
  • 参数str：要截断的 C 字符串
  • 参数delimiters：包含分隔符的 C 字符串
  • 返回值：如果找到分隔符，则指向分隔符开头的指针，否则为空指针

注意事项：
1.参数delimiters是个字符串，定义了作用分隔符的字符集合
2.第一个参数指定一个字符串，它包含了0个或者多个由delimiters字符串中一个或者多个分隔符的标记
3.strtok函数找到str中下一个标记，并将其用’\0’结尾，返回一个指向这个标记的指针（注：strtok函数会改变被操作的字符串，返回在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改）
4.strtok函数的第一个参数不为NULL,函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置
5.strtok函数的第一个参数为NULL,函数将在同一个字符串中被保存的位置开始，查找下一个标记
6.如果字符串中不存在更多的标记，则返回NULL指针

  • 实际使用：
//实际使用strtok
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{const char str1[] = "Hello!China*I love you+lalalala";const char del[] = "!*+";char* ret = NULL;char s[50];//拷贝字符串strcpy(s, str1);//分割打印for (ret = strtok(s, del); ret != NULL; ret = strtok(NULL, del)){printf("%s\n",ret);}return 0;
}
  • 运行结果：

strtok

错误信息报告

strerror

strerro

  • 介绍strerror：

char* strerror(int errnum)

获得一个指向错误信息的地址：解释 errnum 的值，生成一个字符串，其中包含一条消息，该消息描述错误条件，就像库的函数设置为 errno 一样。返回的指针指向静态分配的字符串，程序不得修改该字符串。对此函数的进一步调用可能会覆盖其内容（不需要特定的库实现来避免数据争用）。strerror 生成的错误字符串可能特定于每个系统和库实现。

  • 头文件：#include<stdio.h>
  • 参数errnum：错误码
  • 返回值：错误信息的地址

注意事项：
1.c语言的库函数在运行的时候，如果发生错误，就会将错误存在一个变量中，这个变量是：errno
2.错误码是一些数字：1，2，3，4，5
3.我们需要将错误码翻译成错误信息

  • 实际使用：
//实际使用strerror
#include<stdio.h>
#include<errno.h>
#include<string.h>
int main(void)
{//打开文件FILE* pf = fopen("my.txt","r");if (pf == NULL){printf("%s",strerror(errno));}return 0;
}
  • 运行结果：

strerror

字符分类函数

函数参数符合条件则返回真
iscntrl任何控制字符
isspace空白字符:空格’ ‘,换页’\f’,换行’\n’,回车’\r’,制表符’\t’或者垂直制表符’\v’
isdigit十进制数字0~9
iscdigit十六进制数字,包括十进制数字,小写字母a-f,大写字母A-F
islower小写字母a-f
isupper大写字母A-F
isalpha字母a-z或A-Z
isalnum字母或者数字0-9,a-z,A-Z
ispunct标点符号,任何不属于数字或者字母的图形字符(可打印)
isgraph任何图形字符
isprint任何可打印字符,包括图形字符和空白字符

字符转换函数

tolower

int tolower(int c)

将大写字母转换为小写

toupper

int toupper(int c)

将小写字母转换为大写

内存操作函数

memcpy

memcpy

  • 介绍memcpy

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

复制内存块:将 num 字节的值从源指向的位置直接复制到目标指向的内存块

  • 头文件：#include<string.h>
  • 参数destination：指向要拷贝内容的目标数组的指针，类型转换为 void* 类型的指针
  • 参数source：指向要拷贝的数据源的指针，类型转换为类型为 const void* 的指针。
  • 参数num：要拷贝的字节数（size_t 是无符号整数类型）
  • 返回值：返回destination的指针

注意事项：
1.strcpy只能拷贝字符串，而memcpy可以拷贝内存块
2.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置
3.这个函数在遇到’\0’的时候并不会停下来
4.如果source和的destination有任何的重叠，复制的内容都是未定义的

  • 实际使用：
//实际使用memcpy
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{int src[] = {1,2,3,4,5};int dest[10];//使用memcpymemcpy(dest,src,sizeof(src));//打印int i = 0;for (i = 0; i < (sizeof(src) / sizeof(src[0])); i++){printf("%d ",dest[i]);}return 0;
}
  • 运行结果：

memcpy

  • 模拟实现：
//模拟实现memcpy
#include<stdio.h>
#include<assert.h>
void* my_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;
}
int main(void)
{int src[] = { 1,2,3,4,5,6,7,8,9 };int dest[10] = { 0 };//实现memcpymy_memcpy(dest, src+3, 17);//打印int i = 0;for (i = 0; i < (17 / sizeof(int)); i++){printf("%d ",dest[i]);}return 0;
}

memmove

memmove

  • 介绍memmove:

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

移动内存块:将 num 字节的值从源指向的位置复制到目标指向的内存块。复制就像使用了中间缓冲区一样进行，允许目标和源重叠

  • 头文件：#include<string.h>
  • 参数destination：指向要复制内容的目标数组的指针，类型转换为 void* 类型的指针
  • 参数source：指向要复制的数据源的指针，类型转换为类型为 const void* 的指针。
  • 参数num：要复制的字节数（size_t 是无符号整数类型）
  • 返回值：返回destination的指针

注意事项：
1.与memcpy的差别就是memmove函数处理的源内存和目标内存块是可以重叠的
2.如果源空间和目标空间出现重叠，就可以使用memmove

  • 实际使用：
//实际使用memmove
#include<stdio.h>
#include<string.h>
int main(void)
{int str[] = { 1,2,3,4,5,6,7,8 };//使用memmove//模拟实现memmovememmove(str + 2, str, 20);//打印int i = 0;for (i = 0; i < (sizeof(str) / sizeof(str[0])); i++){printf("%d ", str[i]);}return 0;
}
  • 运行结果：

memmove

  • 模拟实现：
//模拟实现memmove
#include<stdio.h>
#include<assert.h>
void* my_memmove(void* dest, const 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(void)
{int str[] = { 1,2,3,4,5,6,7,8,9,10 };//模拟实现memmovemy_memmove(str + 2, str, 20);//打印int i = 0;for (i = 0; i < (sizeof(str) / sizeof(str[0])); i++){printf("%d ",str[i]);}return 0;
}

memcmp

memcmp
比较俩个内存块：将 ptr1 指向的内存块的第一个 num 字节与 ptr2 指向的第一个 num 字节进行比较，如果它们都匹配，则返回零，或者如果它们不匹配，则返回与零不同的值，表示哪个值更大

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

  • 头文件：#include<string.h>
  • 参数ptr1：指向内存块的指针
  • 参数ptr2：指向内存块的指针
  • 参数num：要比较的字节数
  • 返回值：返回一个整数值，该值指示字符串之间的关系
返回值表明
<0在两个内存块中不匹配的第一个字节在 PTR1 中的值低于 PTR2 中的值（如果计算为无符号字符值）
0两个内存块的内容相等
>0在两个内存块中不匹配的第一个字节在 PTR1 中的值高于 PTR2 中的值（如果计算为无符号字符值）
  • 实际使用：
//实际使用memcmp
#include<stdio.h>
#include<string.h>
int main(void)
{int str1[] = { 1,2,3,4,5 };int str2[] = { 1,2,5,4,5 };//实际使用memcmpint ret = memcmp(str1, str2,4);//打印printf("%d\n",ret);ret = memcmp(str1, str2, 12);//打印printf("%d\n", ret);return 0;
}
  • 运行结果：

memcmp

memset

memset

  • 介绍memset:

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

填充内存块:将 ptr 指向的内存块的第一个 num 字节设置为指定值（解释为无符号字符）

  • 头文件：#include<stdio.h>

  • 参数ptr：指向要填充的内存块的指针

  • 参数value:要设置的值，该值作为 int 传递，但该函数使用此值的无符号字符转换填充内存块

  • 参数num:要填充的字节数（size_t 是无符号整数类型）

  • 返回值：返回 ptr的指针

  • 实际使用：

//实际使用memset
#include<stdio.h>
#include<string.h>
int main(void)
{char str[] = "************";//实际使用memsetmemset(str, 'a', 5);//打印printf("%s",str);return 0;
}
  • 运行结果：

memset

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

基于Springboot的校园生活服务平台（有报告）。Javaee项目，springboot项目。

基于Springboot的校园生活服务平台（有报告）。Javaee项目，springboot项目。

演示视频&#xff1a; 基于Springboot的校园生活服务平台&#xff08;有报告&#xff09;。Javaee项目&#xff0c;springboot项目。 项目介绍&#xff1a; 采用M&#xff08;model&#xff09;V&#xff08;view&#xff09;C&#xff08;controller&#xff09;三层体系结构…
阅读更多...
（已解决）org.springframework.amqp.rabbit.support.ListenerExecutionFailedException

（已解决）org.springframework.amqp.rabbit.support.ListenerExecutionFailedException

报错截图 解决方案 1、登录rabbitMQ网址&#xff0c;删除所有队列 2、重启rabbitMQ 亲测有效&#xff01;&#xff01;&#xff01;亲测有效&#xff01;&#xff01;&#xff01;亲测有效&#xff01;&#xff01;&#xff01;
阅读更多...
简单问题汇总

简单问题汇总

一、vector和list 1.vector vector是可变大小数组的序列容器&#xff0c;拥有一段连续的内存空间&#xff0c;并且起始地址不变&#xff0c;因此能高效的进行随机存取&#xff0c;时间复杂度为o(1)&#xff1b;但因为内存空间是连续的&#xff0c;所以在进行插入和删除操作时…
阅读更多...
torch.searchsorted

torch.searchsorted

torch.searchsorted 官方文档链接&#xff1a;torch.searchsorted — PyTorch 2.3 documentation 该函数用于在已排序的序列中查找要插入的值的位置&#xff0c;以保持序列的顺序&#xff0c; torch.searchsorted(sorted_sequence, values, *, out_int32False, rightFalse, s…
阅读更多...
Redis是单线程吗？为什么6.0之后引入了多线程？

Redis是单线程吗？为什么6.0之后引入了多线程？

Redis是单线程吗&#xff1f;为什么6.0之后引入了多线程&#xff1f; Redis 是单线程吗&#xff1f;Redis 单线程模式是怎样的&#xff1f;Redis 采用单线程为什么还这么快&#xff1f;Redis 6.0 之前为什么使用单线程&#xff1f;Redis 6.0 之后为什么引入了多线程&#xff1f…
阅读更多...
如何使用 ArcGIS Pro 制作地震动画

如何使用 ArcGIS Pro 制作地震动画

在做某些汇报的时候&#xff0c;除了图文&#xff0c;如果有动画肯定会成为加分项&#xff0c;这里为大家介绍一下如何使用 ArcGIS Pro 制作地震动画&#xff0c;希望能对你有所帮助。 添加时间 在图层属性内&#xff0c;选择时间选项卡&#xff0c;图层时间选择每个要素具有…
阅读更多...
GA-CNN-LSTM多输入时序预测|遗传算法-卷积-长短期神经网络|Matlab

GA-CNN-LSTM多输入时序预测|遗传算法-卷积-长短期神经网络|Matlab

目录 一、程序及算法内容介绍&#xff1a; 基本内容&#xff1a; 亮点与优势&#xff1a; 二、实际运行效果&#xff1a; 三、算法介绍&#xff1a; 四、完整程序下载&#xff1a; 一、程序及算法内容介绍&#xff1a; 基本内容&#xff1a; 本代码基于Matlab平台编译&am…
阅读更多...
前端开发指导

前端开发指导

前端开发指导 本文介绍了配置前端开发环境需要的软件、配置项等，指导如何开始进行UDM部门前端开发的全流程。本文以Windows系统下在Microsoft Virtual Studio Code中开发为基础。 一、综述 目标：零基础或者新员工依照此文档，能够完成开发环境的搭建及熟悉测试环境的搭建。…
阅读更多...
Day 29 MySQL的主从复制集群

Day 29 MySQL的主从复制集群

一&#xff1a;主从复制 1.主从复制概念 什么是主从复制&#xff1a; ​ 主从复制&#xff0c;是用来建立一个和主数据库完全一样的数据库环境&#xff0c;称为从数据库&#xff1b;主数据库一般是准实时的业务数据库 主从复制的作用&#xff1a; ​ 做数据的热备&#xf…
阅读更多...
TriCore: Architecture

TriCore: Architecture

说明 本文是 英飞凌 架构文档 TriCore TC162P core archiecture Volume 1 of 2 (infineon.com) 的笔记&#xff0c;稍作整理方便查阅&#xff0c;错误之处&#xff0c;还请指正&#xff0c;谢谢 :) 1. Architecture 2. General Purpose & System Register 名词列表&#…
阅读更多...
【基础算法总结】二分查找一

【基础算法总结】二分查找一

二分查找一 1. 二分查找2.在排序数组中查找元素的第一个和最后一个位置3.x 的平方根4.搜索插入位置 点赞&#x1f44d;&#x1f44d;收藏&#x1f31f;&#x1f31f;关注&#x1f496;&#x1f496; 你的支持是对我最大的鼓励&#xff0c;我们一起努力吧!&#x1f603;&#x1…
阅读更多...
【程序设计和c语言-谭浩强配套】（适合专升本、考研）

【程序设计和c语言-谭浩强配套】（适合专升本、考研）

一晃大半年没更新了&#xff0c;这一年一直在备考&#xff0c;想着这几天把前段时间学的c语言给大家分享一下&#xff0c;在此做了一个专栏&#xff0c;有需要的小伙伴可私信获取o。 简介&#xff1a;本专栏所有内容皆适合专升本、考研的复习资料&#xff0c;本人手上也有日常…
阅读更多...
Android 系统启动流程源码分析

Android 系统启动流程源码分析

一、Init进程启动 是一个由内核启动的用户级进程。内核自行启动之后&#xff0c;就通过启动一个用户级程序init的方式&#xff0c;完成引导进程。 启动的代码init.c中的main函数执行过程&#xff1a;system\core\init.c中&#xff1a; 主要下面两个重要的过程&#xff1a; 1…
阅读更多...
鹦鹉优化算法原理及代码实现

鹦鹉优化算法原理及代码实现

鹦鹉(Pyrrhura Molinae)表现出四种不同的行为特征&#xff1a;觅食、停留、交流和对陌生人的恐惧。这些行为(如图1所示)在现实环境中构成了我们设计PO动机的基础。 觅食&#xff1a;驯化的鹦鹉(Pyrrhura Molinae)的觅食行为令人着迷&#xff0c;因为个体选择在食物丰富的小群体…
阅读更多...
支付宝小程序如何去除页面下拉回弹

支付宝小程序如何去除页面下拉回弹

描述&#xff1a;支付宝小程序页面下拉时会产生回弹&#xff0c;如果页面上有拖拽功能&#xff0c;会有影响 解决方法&#xff1a; 页面xx.config.js中设置&#xff1a;allowsBounceVertical: “NO” 官方文档&#xff1a;https://opensupport.alipay.com/support/FAQ/7110b5d…
阅读更多...
VM虚拟机安装调试（步骤如下图）

VM虚拟机安装调试（步骤如下图）

VM虚拟机安装调试 随着一顿安装操作&#xff0c;还有enter键敲下&#xff0c;出现如下界面。
阅读更多...
深入理解线程的两阶段终止模式：确保线程安全退出

深入理解线程的两阶段终止模式：确保线程安全退出

序言 在多线程编程中&#xff0c;线程的安全退出是一个重要的问题。在实际应用中&#xff0c;我们经常需要确保线程在退出时能够完成必要的清理工作&#xff0c;同时避免因资源泄漏或状态不一致而导致的问题。线程的两阶段终止模式是一种解决这个问题的有效方法。本文将深入探…
阅读更多...
python之并发编程

python之并发编程

python之并发编程 线程的创建方式线程的创建方式(方法包装)线程的创建方式(类包装)join()【让主线程等待子线程结束】守护线程【主线程结束&#xff0c;子线程就结束】 锁多线程操作同一个对象(未使用线程同步)多线程操作同一个对象(增加互斥锁&#xff0c;使用线程同步)死锁案…
阅读更多...
[muduo网络库]——muduo库三大核心组件之 Poller/EpollPoller类（剖析muduo网络库核心部分、设计思想）

[muduo网络库]——muduo库三大核心组件之 Poller/EpollPoller类（剖析muduo网络库核心部分、设计思想）

接着上文&#xff0c;[muduo网络库]——muduo库三大核心组件之Channel类&#xff08;剖析muduo网络库核心部分、设计思想&#xff09;&#xff0c;本章我们来学习muduo网络库中第二大核心组件Poller/EpollPoller类。 先回顾一下三大核心组件之间的关系。 接着我们进入正题。 P…
阅读更多...
Java入门——类和对象（上）

Java入门——类和对象（上）

经读者反映与笔者考虑&#xff0c;近期以及往后内容更新将主要以java为主&#xff0c;望读者周知、见谅。 类与对象是什么&#xff1f; C语言是面向过程的&#xff0c;关注的是过程&#xff0c;分析出求解问题的步骤&#xff0c;通过函数调用逐步解决问题。 JAVA是基于面向对…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023