C语言进阶---字符串+内存函数

本章重点

重点介绍处理字符和字符串的库函数的使用和注意事项。

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

前言

C语言中对字符的字符串的处理很频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。

字符串常量适用于那些对它不做修改的字符串函数。

1、字符串函数

1.1、strlen()—统计字符串长度

//头文件<string.h>size_t strlen(const char* str);
  • 首先传的参数需要是个指针类型的。
  • 字符串以'\0'作为结束标志，strlen()函数返回的是在字符串中'\0'前面出现的字符个数（不包含'\0'）。
  • 参数指向的字符串必须要以'\0'结束。
  • 注意函数的返回值为size_t，是无符号整型的
  • 学会strlen()函数的模拟实现。

1.2、strcpy()—字符串拷贝

//头文件<string.h>char* strcpy(char* destination, const char* source)
  • 源字符串必须以'\0'结束。
  • 会将源字符串中的'\0'拷贝到目标空间。
  • 返回值为目标字符串的首字符地址。
  • 目标空间必须足够大，以确保能存放源字符串。
  • 目标空间必须可变。
  • 学会模拟实现。

简单使用介绍：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>int main()
{char name[20] = { 0 };strcpy(name, "zhangsan");printf("%s\n", name);return 0;
}

输出：

在这里插入图片描述

1.3、strcat()—字符串追加

//头文件<string.h>
char* strcat(char* destination, const char* source)
  • 源字符串必须以'\0'结束。
  • 源字符串在目标字符串有\0的地方开始追加。并不是说只会在目标字符串末尾处开始追加，只要目标字符串中间某个位置有\0，那就直接从这个位置开始追加。
  • 目标空间必须有足够的大，能容纳下源字符串的内容。
  • 目标空间必须可修改

1、简单使用介绍：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>int main()
{char arr2[20] = "hello ";strcat(arr2, "world");printf("%s\n", arr2);return 0;
}

输出：

在这里插入图片描述

2、这里说明一下：源字符串在目标字符串有\0的地方开始追加。并不是说只会在目标字符串末尾处开始追加，只要目标字符串中间某个位置有\0，那就直接从这个位置开始追加。

如下代码：“hel\0lo”，中间位置有个\0，所以在追加"world"是，就直接从"hel"初开始追加了。最后输出结果就是:

“helworld”。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>int main()
{char arr2[20] = "hel\0lo ";strcat(arr2, "world");printf("%s\n", arr2);return 0;
}

输出：

在这里插入图片描述

2、模拟实现：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>char* my_strcat(char* dest, const char* source)
{char* ret = dest;assert(dest && source);//1、找到目标字符串的\0。while (*dest != '\0'){dest++;}//2、拷贝while (*dest++ = *source++){;}return ret;
}int main()
{char arr1[20] = "hello ";my_strcat(arr1, "world");printf("%s\n", arr1);return 0;
}

那能不能实现字符串自己给自己追加？如下：

答案：是不能的。

int main()
{char arr1[20] = "hello ";my_strcat(arr1, arr1);             //如何实现这样的效果呢？printf("%s\n", arr1);return 0;
}

1.4、strcmp()—比较字符串大小

//头文件<string.h>
int strcmp(const char* str1, const char* str2);
  • 返回值：
    • 第一个字符串<第二个字符串，就返回小于0的数字
    • 第一个字符串=第二个字符串，就返回0
    • 第一个字符串>第二个字符串，就返回大于0的数字

那具体是怎么比较的呢？是依次比较各个字符串中字符的ASCII值。

比如：首先arr1中的字符’a’和arr2中的字符’a’进行比较，发现ASCII一样，然后再比较字符’b’…

之后当比较到arr1中的字符’d’和arr2中的字符’f’是，发现arr2中的’f’的ASCII值比arr1中的’d’的ASCII值大。

所以最终结果为arr2大。

char arr1[] = "abcd";
char arr2[] = "abcf";

1、简单使用：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>int main()
{char arr1[] = "abcd";char arr2[] = "abcf";int ret = strcmp(arr1, arr2);    //arr1小于arr2if (ret < 0)printf("<\n");else if (ret == 0)printf("=\n");elseprintf(">\n");return 0;
}

输出：

在这里插入图片描述

2、模拟实现：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <assert.h>int my_strcmp(const char* str1,const char* str2)
{assert(str1 && str2);while (*str1 == *str2){if (*str1 == '\0')return 0;   //判断相等str1++;str2++;}if (*str1 > *str2)return 1;elsereturn -1;
}int main()
{char arr1[] = "abcd";char arr2[] = "abcf";int ret = my_strcmp(arr1, arr2);if (ret < 0)printf("<\n");else if (ret == 0)printf("=\n");elseprintf(">\n");return 0;
}//判断>或者<的返回值还可以在优化：
//将下面一段代码替换为最后一行优化的代码
if (*str1 > *str2)return 1;elsereturn -1;//替换这个优化的代码
return *str1 - *str2;

关于以上库函数不安全的说明

上面所说到了库函数，其实是相对不安全的，比如：

#include <stdio.h>
#include <string.h>int main()
{char arr1[] = "abcd";char arr2[] = "abcdfr";//arr2的字符长度比arr1的字符长度长，当让arr2拷贝到arr1时，arr1数组会放不下，//放不下编译器也会放，那就呆滞了越界访问，以至于改变了其它内存中的数据，这是相当危险的。strcpy(arr1, arr2);   return 0;
}

那这个时候，就应用诞生了相对来说安全一点的库函数：长度受限制的的字符串函数。

长度受限制的字符串函数是什么意思呢？下面介绍：

1.5、strncpy()–长度受限制拷贝

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

多个参数：num。这个参数就是限制长度的参数，比如说让arr2的字符串拷贝到arr1中去，但是只允许拷贝3个字节的字符:

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>int main()
{char arr1[] = "aaaaa";char arr2[] = "bbbbb";//让arr2的数据拷贝到arr1中去，但是只拷贝3个字节。strncpy(arr1, arr2,3);   printf("%s\n", arr1);return 0;
}

输出：

在这里插入图片描述

可以看到输出结果：只会将arr2中的前3个字符拷贝到arr1中，arr1前3个也字符会改变，并且后面的字符不会改变。

1.6、strncat()—长度受限制追加

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>int main()
{char arr1[20] = "hello\0xxxxxx";char arr2[] = "world";strncat(arr1, arr2, 3);printf("%s\n", arr1);return 0;
}

输出：这里有个点要注意以下：在使用strncat()时，在追加完毕后，会自动在目标字符串末尾添加一个\0表示一个字符的结束。

这里采用调试查看：

在这里插入图片描述

1.7、strncmp()—长度受限制比较

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>int main()
{char arr1[] = "abcdef";char arr2[] = "abc";strncmp(arr1, arr2, 3);   //只比较3个字符，结果应该为相等。return 0;
}

1.8、strstr()—查找子串

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

参数说明：

  • str1是母字符串的地址
  • str2是子串的地址

比如现在有两个字符串：

char arr1[] = "abcdef";
char arr2[] = "cde"
strstr(arr1,arr2);

需要在arr1（母字符串）中寻找有没有arr2（子串）的内容。首先arr2中的字符串内容为：“cde”，而arr1中的字符串：“abcdef”，正好全部包含"cde"。那么此时strstr()函数会返回arr1中包含子串的首字符地址。也就是会返回arr1中字符c的地址。那如果我们在以%s打印时，就会将arr1的"cdef"的值全部打印出来，因为从起始位置’c’到’\0’结束，就是"cdef"。

所以strstr()函数的返回值是个char*类型的。

如果没有查找到字串，就会返回一个NULL指针。

1、使用演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>int main()
{char arr1[] = "abcdef";char arr2[] = "cde";char* ret = strstr(arr1, arr2);if (ret == NULL){printf("没有找到\n");}else{printf("%s\n", ret);}return 0;
}

输出：

在这里插入图片描述

1.9、strtok()—切割字符串

char* strtok(char* str, const char* sep);

  • sep参数是个字符串，定义了用作分隔符的字符集合。

    比如现在有一个字符串：“zhengbo@helloworld.com”，假如字符@和字符.就是我们分隔符，通过这两个符号，可以将字符串切割为一段一段的。那我们就可以这样定义这个sep参数：

    const char* sep = "@.";

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

    这里的第一个参数就是要切割的字符串：

    char arr[] = "zhengbo@helloworld.com";

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

    strtok函数找到了str中的下一个标记这句话的意思就是说，strtok找到了@分隔符，就会把@分隔符变为'\0'，那arr数组就会变成如下的样子：

    char arr[] = "zhengbo\0helloworld.com";

    然后返回一个指向这个标记的指针，就是把分隔好的字符串：“zhengbo\0”，通过返回字符'z'的地址，作为指针返回过去。

    但是这样我们会发现一个问题：就是会把arr数组里面的内容给修改。那如果下面程序还需要使用arr数组呢？那情况就不对。所以说我们先应该使用strcmp()函数把arr数组给临时拷贝一份给另外一个数组，然后把临时拷贝的数组交给strtok来进行操作，那这样既能提取出来分隔的字符串，又能不对原数组arr进行修改。具体实现如下代码：

    #include <stdio.h>
#include <string.h>
int mian()
{const char* sep = "@.";char arr[] = "zhengbo@helloworld.com";char cp[30] = { 0 };strcmp(cp,arr);     //临时拷贝一份strtok(cp, sep);    //对临时拷贝的数组进行分隔return 0;
}

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

    这个是说，我们在首次使用strtok函数时，需要传第一个参数，因为第一个参数里面保存了分隔符的地址，有了一个参数后，函数将找到str中第一个标记，也就是说找到了@标记（分隔符），然后返回首字符z的地址，作为函数返回值，然后保存下来。

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

    到这一步，再次调用strtok函数，需要找第二个，第三个，第四个分割符的时候就不需要传第一个参数了，所以到这个地方我们就能明白，只有在找第一个分隔符的时候才传第一个参数。好，那问题又来了：那不传第一个参数，如何找到，下一个需要分割为字符串的首字符地址呢？原因是这样的：其实在找到第一个分隔符之后，NULL指针表示一种状态，NULL指针会记录着上一个分割后的起始位置，也就已经记着了第一个分隔符后面的字符地址了。然后在根据sep中记录的分隔符，分割出一段字符串。

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

    到这一步，是说，在真个arr数组里面没找到分隔符，那就直接strtok函数返回NULL指针。

1、效果演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
int main()
{//创建分隔符集合const char* sep = "@.";//待分割的字符串char arr[] = "zhengbo@helloworld.com";//创建一个临时数组char cp[30] = { 0 };//拷贝一份临时数据strcpy(cp,arr);//切割出zhengbo@，并把@换为\0了，且把z字符的地址，返回给了ret。char* ret = strtok(cp, sep);    //打印出：zhengboprintf("%s\n", ret);//打印helloworld，这里的NULL指针表示一种状态，NULL指针记录了'h'的地址ret = strtok(NULL, sep);printf("%s\n", ret);//打印com，这里NULL指针记录了'c'的地址ret = strtok(NULL, sep);printf("%s\n", ret);return 0;
}

输出：

在这里插入图片描述

2、优化：上面的代码分割一个字符串就需要打印一次，其实这里可以写个for循环，来优化下代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
int main()
{const char* sep = "@.";char arr[] = "zhengbo@helloworld.com";char cp[30] = { 0 };//拷贝一份临时数据strcpy(cp,arr);//切割出zhengbo@，并把@换为\0了，且把z字符的地址，返回给了ret。char* ret = NULL;//优化部分for (ret = strtok(cp, sep); ret != NULL; ret = strtok(NULL, sep)){printf("%s\n", ret);}return 0;
}

1.10、strerror()

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

//头文件：<errno.h>
char* strerror (int errnum);

在C语言中，库函数在执行失败的时候，都会设置错误码。

虽说设置的都有错误码，但是我们怎么样才能知道错误码所对应的错误信息呢？

这个时候strerror()函数就起作用了。只需要把错误码传参进去，这个函数就会返回错误码所对应错误信息字符串的首字符地址。

1、代码演示：

//在X86平台上运行#include <stdio.h>
#include <errno.h>int main()
{printf("%s\n", strerror(0));printf("%s\n", strerror(1));printf("%s\n", strerror(2));printf("%s\n", strerror(3));return 0;
}

输出：

在这里插入图片描述

2、情景演示

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <errno.h>int main()
{//使用fopen()表示打开一个文件，并且r表示以只读的方式进行。//如果打开成功会返回一个指针，如果打开失败会返回NULL指针。//现在本地没有test.txt文件，所以会打开文件失败，返回NULL指针。FILE* pf = fopen("test.txt", "r");if (pf == NULL){//errno是C语言中设置一个全局变量，用来专门存放错误码的。printf("%s\n", strerror(errno));return 1;}return 0;
}

输出：

在这里插入图片描述

2、字符分类函数

函数如果它的参数符合下列条件就返回真
iscntrl任何控制字符
isspace <ctype.h>空白字符：空格’ ‘，换页’\f’，换行’\n’，回车’\r’，制表符’\t’，垂直制表符’\v’
isdigit <ctype.h>十进制数字0~9
isxdigit十六进制数字，包括所有十进制数字，小写字母af，大写字母AF
islower小写字母a-z
isupper大写字母A-Z
isalpha字母az或AZ
isalnum字母或数字，az、AZ、0~9
ispunct标点符号，任何不属于数字或字母的图形字符（可打印）
isgraph任何图形字符
isprint任何可打印字符，包括图形字符和空白字符

3、字符转换函数

字符转换：

1、tolower()-------------将大写字母转为小写

int tolower(int c);     //将大写字母转为小写，如果传参数表示大写字母，给什么值，输出什么值。

代码演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <ctype.h>int main()
{printf("%c\n", tolower('A'));return 0;
}

输出：

在这里插入图片描述

2、toupper()----------------将小写字母转为大写

int toupper(int c);     //将小写字母转为大写，如果传参数表示小写字母，给什么值，输出什么值。

代码演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <ctype.h>int main()
{printf("%c\n", toupper('g'));return 0;
}

输出：

在这里插入图片描述

4、内存操作函数

4.1、memcpy函数—内存拷贝（不能用来拷贝重叠内存）

void* memcpy (void* destination, const void* source, size_t num);
  • 函数memcpy从source的位置开始向后复制num个__字节__的数据到destination的内存位置。
  • 这个函数在遇到’\0’的时候并不会停下来。
  • 如果source和destination有任何的重叠，复制的结果都是未定义的。

上面讲到字符函数也有两个拷贝：strcpy、strncpy。

但是这两个库函数都是指针字符串进行拷贝的。

那现在有两个整型数组，如何拷贝呢？

比如：

  • int arr1[] = {1,2,3,4,5,6};
  • int arr2[10] = {0};

这个时候就需要使用memcpy()库函数了。

在介绍这个库函数前，先来思考一下这个库函数诞生的原因：如果需要拷贝字符类型的数据用到了strcpy、strncpy函数，那如果需要拷贝整型数据的呢？需要产生一个专用于整型拷贝的库函数吗？如果需要拷贝浮点型呢？如果需要拷贝结构体呢？不可能说都会产生一个对应的拷贝库函数。

而是说直接用一个memcpy()函数，这个函数是直接对内存进行操作的，它拷贝的是内存块里面的数据。而无论是字符还是整形，或者是浮点型，再或者是结构体。它们的数据都是存放在内存中的。所以说可以直接用memcpy()函数进行统一拷贝操作。

1、参数介绍：

//头文件   <string.h>
void * memcpy ( void * destination, const void * source, size_t num );
  • destination目标地址
  • source 源地址
  • 参数num的单位是字节。

2、代码演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>int main()
{int arr1[] = { 1,2,3,4,5,6,7 };int arr2[10] = { 0 };//因为一个整型是4个字节，arr1里面有7个整型数字，所以是28个字节，//memcpy的三个参数num的单位是字节，所以应传参28//将arr1的数据拷贝到arr2中memcpy(arr2, arr1, 28);return 0;
}

调试查看：

在这里插入图片描述

3、模拟实现memcpy()函数

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.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()
{int arr1[] = { 1,2,3,4,5,6,7 };int arr2[10] = { 0 };//因为一个整型是4个字节，arr1里面有7个整型数字，所以是28个字节，//memcpy的三个参数num的单位是字节，所以应传参28my_memcpy(arr2, arr1, 28);return 0;
}

4.2、memmove函数------内存拷贝（可以用来重叠内存之间的拷贝）

memcpy函数和memmove函数基本功能大致一样，但是memmove有个比memcpy强大的小功能：

1、memcpy函数是不能用来处理重叠的内存之间的数据拷贝。

2、memmove函数是可以处理重叠内存之间的数据拷贝的。

3、 memcpy只是memmove的一个子集。

memmove函数的参数和memmove函数的参数是一样的：

//头文件   <string.h>
void * memmove ( void * destination, const void * source, size_t num );

既然参数一样，那两个函数的用法也是一样的。

假如如下是数组arr1重叠部分：

在这里插入图片描述

下面来实现内存重叠的代码演示：

#include <stdio.h>
#include <string.h>int main()
{int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };memmove(arr1, arr1 + 2, 20);int i = 0;for (i = 0; i < 10; i++){printf("%d ", arr1[i]);}return 0;
}

输出：

在这里插入图片描述

4.3、memcmp—内存比较

//头文件   <string.h>
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
  • num参数是字节。
  • 比较从ptr1和ptr2指针开始的num个__字节__。
  • 返回值如下：
    • ptr1内存块中存储的数据比ptr1内存块中存储的数据大，就返回>0的值
    • ptr1内存块中存储的数据比ptr1内存块中存储的数据小，就返回<0的值
    • 如果将所指定的num字节全部比较完毕后，还是一样的大小，会返回0.

1、代码演示：

#include <stdio.h>
#include <string.h>int main()
{int arr1[] = { 1,2,3,4,5 };int arr2[] = { 1,3,2 };//这里num为12，表示比较12个字节的内容，一个int占用4个字节，所以一共比较3个数字。int ret = memcmp(arr1, arr2, 12);printf("%d\n", ret);return 0;
}

输出：

在这里插入图片描述

分析：是如何比较出来大小的呢？

首先arr1中的数字在内存中是这样存储的：
01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00

然后arr2中的数字在内存中是这样存储的：

01 00 00 00 03 00 00 00 02 00 00 00

因为我们指定了只比较12个字节的数据，所以两个数组开始从头比较，直到比较到第五个字节（如下图）：

arr1的数据是02，arr2的数据是03。这样一来比较大小就有了结果。是arr2大。所以返回-1<0的值。

在这里插入图片描述

4.4、memset—内存设置

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

参数说明：

  • ptr：需要填充的内存块的地址。
  • value：要被填充的内容，（看着是int类型的，其实可以传char类型的数据，因为字符在内存中存储也是按照ASCII值存储的）。
  • num：要被填充多少个字节。

1、代码演示：

#include <stdio.h>
#include <string.h>int main()
{char arr[] = "hello bbo";//表示，从整个字符数组首字符开始，一直填充5个'x'字符。memset(arr, 'x', 5);printf("%s\n", arr);return 0;
}

输出：

在这里插入图片描述

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

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

相关文章

FPGA实验二：模可变计数器设计

FPGA实验二：模可变计数器设计

目录 一、实验目的 二、实验要求 三、实验代码 1.实验源码 2.部分代码设计思路分析 四、实验结果及分析 1、引脚锁定 2、仿真波形及分析 3、下载测试结果及分析 五、实验心得 1.解决实验中遇到的困难及解决 2.完成实验后的心得 一、实验目的 &#xff08;1&#xf…
阅读更多...
Jenkins用户权限设置和运行节点配置实战

Jenkins用户权限设置和运行节点配置实战

这里写目录标题 一、Jenkins用户权限设置实战1、用户权限配置2、用户权限分配 二、Jenkins运行节点配置实战1、增加运行节点的好处2、实战B-1:添加Jenkins运行节点实战1、相关字段说明&#xff1a;2、SSH连接方式 实战B-2:配置不同类型的节点-Python 节点实战B-3:配置不同类型的…
阅读更多...
【Java|golang】2679. 矩阵中的和

【Java|golang】2679. 矩阵中的和

给你一个下标从 0 开始的二维整数数组 nums 。一开始你的分数为 0 。你需要执行以下操作直到矩阵变为空&#xff1a; 矩阵中每一行选取最大的一个数&#xff0c;并删除它。如果一行中有多个最大的数&#xff0c;选择任意一个并删除。 在步骤 1 删除的所有数字中找到最大的一个…
阅读更多...
什么是DevOps？ 什么是DORA？

什么是DevOps？ 什么是DORA？

1. 前言 对于搞云原生应用的同学&#xff0c;对于DevOps和DORA应该都不陌生。但对于传统应用程序开发的同学&#xff0c;经常被DevOps, Microservice, CICD, DORA这些新颖的名词搞得晕头转向。那么到底什么是DevOps? 什么是DORA呢&#xff1f; 2. 解析 2.1 DevOps DevOps并…
阅读更多...
Linux进程概念

Linux进程概念

目录 冯诺依曼体系结构 操作系统 系统调用和库函数概念 进程 描述进程-PCB 组织进程 理解进程 查看进程 通过系统调用获取进程标示符 通过系统调用创建进程-fork 进程状态 进程状态查看 孤儿进程 进程优先级 查看系统进程 PRI and NI PRI vs NI 用top命令更改…
阅读更多...
官宣 | 平行云正式升级为Paraverse平行云科技，开启全球业务新征程

官宣 | 平行云正式升级为Paraverse平行云科技，开启全球业务新征程

6月30日, "Here is New-Gen Web"——Paraverse Global Strategy and Brand Launch Party 于香港科学园召开&#xff0c;会上平行云正式宣布升级为Paraverse平行云科技&#xff08;以下简称Paraverse)&#xff0c;并升级品牌标识“Paraverse”。这一全新命名与视觉焕新…
阅读更多...
LabVIEW仿真单频脉冲信号+线性调频信号+高斯白噪声信号

LabVIEW仿真单频脉冲信号+线性调频信号+高斯白噪声信号

文章目录 前言一、单频脉冲信号1、信号参数2、仿真图①、前面板②、程序框图 二、线性调频信号1、信号参数2、仿真图①、前面板②、程序框图 三、高斯白噪声信号1、信号参数2、仿真图①、前面板②、程序框图 四、合成信号1、前面板2、程序框图 五、代码自取 前言 本文基于 Lab…
阅读更多...
day28-JSP

day28-JSP

0目录 JSP 1.为什么使用JSP 2.B/S和C/S的区别 3.URL 4.Tomcat 5.JSP实战综合项目 1.为什么使用JSP 1.1 JSP定义&#xff1a; &#xff08;1&#xff09;是一种动态网页技术 &#xff08;2&#xff09;Java Server Pages&#xff08;Java服务器端页面技术&#xff09; 1.2 …
阅读更多...
干货 | 石化产品机器学习价格模型开发和SEI石化产品价格分析体系构建

干货 | 石化产品机器学习价格模型开发和SEI石化产品价格分析体系构建

以下内容整理自大数据能力提升项目必修课《大数据系统基础》同学们的期末答辩汇报。 我们的报告将分为六个部分&#xff0c;第一部分是研究背景与内容。受疫情影响以来&#xff0c;石化行业市场日趋饱和&#xff0c;竞争激烈&#xff0c;同时利润也受到压缩&#xff0c;大部分石…
阅读更多...
5G NR：RACH随机接入过程

5G NR：RACH随机接入过程

1. 简述 无论是3G,4G还是现在的5G都需要随机接入过程&#xff0c;随机接入过程主要是为了让基站和UE之间做好上行同步以及初始接入。此文章仅仅帮助大家了解此过程&#xff0c;更加具体的用途及其场景需要参考具体的3GPP协议&#xff08;38.211,38.212,38.213).主要帮助理解如下…
阅读更多...
【Spark实战】Windows环境下编译Spark2 Linux上部署Spark On Yarn

【Spark实战】Windows环境下编译Spark2 Linux上部署Spark On Yarn

Windows环境下编译Spark2 环境准备 git-2.14.1maven-3.9.2jdk-1.8scala-2.11.8zinc-0.3.15 主下载地址spark-2.3.4 github官方地址 编译准备 maven远程仓库使用的是阿里云的 解压源码包spark-2.3.4.zip,修改根模块的pom文件。主要目的是为了变更hadoop的版本号&#xff0c;…
阅读更多...
【数据可视化】大作业（意向考研高校的数据可视化）

【数据可视化】大作业（意向考研高校的数据可视化）

文章目录 前言一、数据介绍1.1 基本信息1.2 考研信息1.3 导师信息 二、预处理及分析2.1 数据预处理2.1.1 考研信息预处理2.1.2 导师信息预处理 2.2 数据分析 三、可视化方法及结果3.1 可视化方法3.2 可视化结果展示3.2.1 基本信息3.2.2 考研信息3.2.3 导师信息 四、总结五、附录…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023