08- c语言字符串 (C语言)

news2024/12/24 20:15:37

一  字符串的定义及基本使用

1、什么是字符串

被双引号引用的字符集合!例如:”hello” 、”world”,或者是以 '\0' 结尾的字符数组!!!
比如:char ch[] = {'h', 'e', '\0'}
注意:”hello” 中其实在在末尾也有'\0' 只是我们看得到。

也就是说:字符串 一定是以 '\0'结尾 的!!
如何验证”hello”中有字符'\0'呢?
printf("%d\n", *(p+5)); 输出的结果为整数0则说明结尾是'\0'

2、字符串和字符数组的联系及区别

可以把字符串当做字符数组一样处理,字符数组不一定可以当做字符串处理,为什么?
因为字符数组中不一定有 '\0'。

char ch[] = {‘a’, 'b', '\0', 'c', 'd'};

这种情况我们可以把数组ch当成字符串 “ab”
在实际工作过程中我们经常会有如下需求,我们需要用一个字符数组用来保存多个字符,并且需要将这多个字符当成字符串 ,但是我们在定义字符数组的时候只知道需要保存的字符的最大的数目(假设是30),实际存储的时候存储的字符可能会小于30,如何保障把这些字符当成字符串呢?

c har name[ 30 ] ;
memset(name, 0, sizeof(name));

注意:在定义字符数组长度的时候 通常要比实际要存储的字节数的数目+1(因为最后需要留一个字节存 ’ \0 ’ )。

3、字符串的操作

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

int main(){
    //字符串的操作:
    char *str;
    char ch[] = {"hello"};
    str = ch;
    //可以通过指针str操作ch
    //方法1:
    str[1] = 'a'; //当一个指针指向了一个数组以后,我们就可以通过指针使用下标法直接访问数组中的元素
    //方法2:
    *(str + 1) = 'a';
    //也可以将字符串常量赋值给一个指针变量
    char *p = "hello";
    /*注意:p是一个指针变量,应该保存的是一个地址,因此 char *p = "hello"; 并不是将字符串"hello"赋值给
    指针变量p,而是将存储字符串 "hello"的内存空间的首地址赋值给p
    */
    return 0;
}

4、将字符数组中的每个元素赋值为'\0'

#include <string.h>
void *memset(void *s, int c, size_t n);

memset 功能:将指针s所指向的内存空间中的n个字节填充成c
示例代码:

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

int main()
{
    char ch[10];
    memset(ch, 0, sizeof(ch)); //memset(ch, 0, sizeof(ch));
    printf("view the data ch: %d\n", ch[0]);
    return 0;
}

5、请分析下面代码有何问题?

char *p = "hello";
p[0] = 'A';

二 常见的字符串处理函数

1、atoi函数

#include <stdlib.h>
int atoi(const char *nptr);

功能:将字符串转换成int类型 的整数,返回转换后的整数值。

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

int main(){
    char *p = "1234";
    int val = atoi(p);
    printf("view the data: %d\n", val);
    return 0;
}

练习:编写代码实现atoi函数

2、atof函数

#include <stdlib.h>
double atof(const char *nptr)

功能:将 字符串转换成double类型的浮点数,返回转换后的浮点数

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

int main()
{
    char *p = "123.456";
    double val = atof(p);
    printf("%f\n", val);
    return 0;
}

3、strlen函数

#include <string.h>
size_t strlen(const char *s);

功能:计算字符串的长度

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

int main()
{
    char *ch = "hello";
    char arr[] = {'A', 'B', 'C', '\0', 'D'};
    printf("%d %d\n", strlen(ch), strlen(arr));
    return 0;
}

思考:为什么strlen(arr)得结果是3呢?
练习:编程实现strlen函数

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

int main(){
    char *ch = "hello";
    char arr[] = {'A', 'B', 'C', '\0', 'D'};
    printf("%d  %d\n", strlen(ch), strlen(arr));
    return 0;
}

思考:为什么strlen(arr)得结果是3呢?
练习:编程实现 strlen函数

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

int my_strlen(char ch[]) //int my_strlen(char *ch)
{
    int cnt = 0;
    int i = 0;
    while (ch[i] != '\0')
    {
        cnt++;
        i++;
    }
    return cnt;
}

4、strcpy函数

#include <string.h>
char *strcpy(char *dest, const char *src);

功能:把src所指向的字符串复制到dest所指向的空间中,'\0'也会拷贝过去
参数:
dest目的字符串 首地址
src源字符首地址
返回值:
成功:返回dest字符串的首地址
失败:NULL

示例代码:

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

int main(){
    char *src = "hello";
    char dst[10] = {0};
    strcpy(dst, src);
    printf("src: %s, dst: %s\n", src, dst);
    return 0;
}

注意:
1、dst的空间一定要大于从src中需要拷贝的内容所占用的空间,至少大1个字节(因为要给'\0'预留空间)。

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

int main(){
    char a[4];
    char b[4];  //hello
    strcpy(b, "hello");
    printf("view the data b: %s\n", b);  //hello
    printf("view the data a: %s\n", a);  //0
    return 0;
}

2、strcpy的实现

char *strcpy(char *dest, const char *src, size_t n){
    size_t i;
    for (i=0;i<n && src[i] != '\0'; i++)
        dest[i] = src[i];
    for (; i<n; i++)
        dest[i] = '\0';
    
    return dest;
}

5、strncpy 函数

#include <string.h>
char *strncpy(char *dest, const char *src, size_t n);

功能:把src指向字符串的前n个字符复制到dest所指向的空间中,是否拷贝结束符看指定的长度是否包含'\0'。
参数:
dest:目的字符串首地址
src:源字符首地址
n:指定需要拷贝字符串个数
返回值:
成功:返回dest字符串的首地址
失败:NULL

注意:
1、strncpy最多拷贝n个字节,如果前n个字节中没有'\0',最终也不会拷贝'\0'
2、如果src的长度小于n,则会写入一些'\0'以保障总共写入n个Bytes,strncpy在拷贝的时候如果前面的n个字节中已经有'\0'了,则只拷贝到'\0',但是依然会往dest中继续写入'\0'以保障总共写入n个Bytes。
strncpy的实现:

char *strncpy(char *dest, const char *src, size_t n){
    size_t i;
    for (i=0; i<n && src[i] != '\0'; i++)
        dest[i] = src[i];
    for (; i<n; i++)
        dest[i] = '\0';
    return dest;
}

6、strcpy和strncpy的区别

如果你能够100%肯定dest的空间比src的空间大,可以使用strcpy
在实际工作中为了避免溢出情况的产生我们尽量多使用strncpy
问题又来了!如果使用strncpy的时候n比dest所指向的内存空间的大小要大那不是还是会产生溢出吗?那么如何去规避这种溢出情况的产生呢?
方法:先判断dest的长度len和n的大小,  如果len>=n,则拷贝n个元素,如果len<n,则拷贝len个元素!

7、strcat 函数

#include <string.h>
char *strcat(char *dest, const char *src);

功能:将src字符串连接到dest的尾部,‘\0’也会追加过去
参数:
dest:目的字符串首地址
src:源字符首地址
返回值:
成功:返回dest字符串的首地址
失败:NULL
示例代码:

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

int main(){
    char ch[20];
    memset(ch, 0, sizeof(ch));

    strcpy(ch, "hello");
    strcat(ch, "world");
    printf("view the data: %s\n", ch);
    return 0;
}

注意:ch的空间要足够大!
strcat的实现:

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

char *strncat(char *dest, const char *src, size_t n){
    size_t dest_len = strlen(dest);
    size_t i;
    
    for (i=0; i<n && src[i] != '\0'; i++)
        dest[dest_len + i] = src[i];
    dest[dest_len + i] = '\0';
    return dest;
}

8、strncat 函数

#include <string.h>
char *strcat(char *dest, const char *src);

功能:将src字符串连接到dest的尾部,‘\0’也会追加过去
参数:
dest:目的字符串首地址
src:源字符首地址
返回值:
成功:返回dest字符串的首地址
失败:NULL
注意:

  • 如果src中的内容长度为m小于n个字节,那么只追加m+1个字节(最后会自动追加一个'\0')
  • 如果src中的内容长度为m小于n个字节,那么追加n+1个字节(最后会自动追加一个'\0')

示例代码:

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

int main(){
    char *p;
    p = (char *)malloc(20);
    strcpy(p, "hello");
    strncat(p, "world", 3);
    printf("%s\n", p);

    memset(p, 0, 20);
    strcpy(p, "hello");
    strncpy(p, "world", 7);
    printf("%s\n", p);
    return 0;
}

strcat 的实现:

char *strncat(char *dest, const char *src, size_t n){
    size_t dest_len = strlen(dest);
    size_t i;
    
    for (i=0; i<n && src[i] !='\0'; i++)
        dest[dest_len + i] = src[i];
    dest[dest_len + i] = '\0';
    return dest;
}

 区别总结如下:

  • strcat完整地连接源字符串到目标字符串的末尾,直到遇到源字符串的结尾字符。
  • strncat 限制了连接的字符数,只连接源字符串的前n个字符。

9、strcmp函数

#include <string.h>
int strcmp(const char *s1, const char *s2);

功能:strcmp 会按照字典顺序 逐个比较两个字符串的字符。比较规则如下:

  • 首先比较两个字符串的第一个字符,如果相等则继续比较下一个字符。
  • 如果两个字符串在某个位置的字符不相等,那么比较结果就是两个字符的ASCII码差值。
  • 如果其中一个字符串已经结束(遇到了空字符\0),而另一个字符串还有剩余字符,那么较短的字符串被视为小于较长的字符串。

参数:

  • s1:字符串1首地址
  • s2:字符串2首地址

返回值

  • 相等:0
  • 大于:>0 在不同操作系统strcmp结果会不同 返回ASCII差值
  • 小于:<0

原理:
strcmp的执行的逻辑:将s1和s2中对应位置的字符一一比较,直到两个字符串全部遍历完成(如果还没有发现有不同的字符则说明两者相等),或者有两个字符不相等,则比较结束。如果s1中的字符的ASCII码比s2中的大则返回1,否则返回-1
注意:有的编译器两个字符串

int main(){
    printf("%d\n", strcmp("hello", "hello"));  //前面等于后面,结果为0
    printf("%d\n", strcmp("hello", "heLlo"));  //前面大于后面,结果为1
    printf("%d\n", strcmp("Hello", "heLlo"));  //前面小于后面,结果为-1
    return 0;
}

10、strncmp函数

#include <string.h>
int strncmp(const char *s1, const char *s2, size_t n);

功能:比较 s1 和 s2 前n个字符的大小,比较的是字符ASCII码大小。
参数:

  • s1:字符串1首地址
  • s2:字符串2首地址

n:指定比较字符串的数量
返回值

  • 相等:0
  • 大于: > 0
  • 小于: < 0

练习1:
在键盘上输入一串字符串,判断这个字符串和在程序中所设定的字符串是否相等(最多比较6个字符)(不区分大小写)

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

int main(){
    char ch1[10];
    char key[] = "A18Cd9";
    memset(ch1, 0, sizeof(ch1));
    printf("please input the key: %s\n", key);
    scanf("%s", ch1);
    printf("view the data ch1: %s\n", ch1);
    return 0;
}

练习2:
在键盘上输入一串字符串,将其中的非字母和非数字的字符删除!

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

int main(){
    char ch1[10];
    memset(ch1, 0, sizeof(ch1));
    printf("plz input the data:\n");
    scanf("%s", ch1);
    printf("the data ch1: %s\n", ch1);
    return 0;
}

11、strstr 函数

strstr是C语言中的一个字符串查找函数,用于 在一个字符串中查找子串的出现位置

#include <string.h>
char *strstr(const char *haystack, const char *needle);

功能:在字符串haystack中查找字符串needle出现的位置
参数:

  • haystack:源字符串首地址
  • needle:匹配字符串首地址

返回值

  • 成功:返回第一次出现的needle地址
  • 失败:NULL
  • 我们经常使用strstr来判断某个字符串是否时另外一个字符串的字串!
int main(){
    char src[] = "ddddsabcd12233dsfl23dlf09a1";
    char *p = strstr(src, "abcd");
    printf("p = %s\n", p);
    return 0;
}

12、strtok函数

strtok是C语言中的字符串分割函数,用于 将一个字符串按照指定的分隔符进行分割

#include <string.h>
char *strtok(char *str, const char *delim);

功能:来将字符串分割成一个个片段。当strtok()在参数s的字符串中发现参数delim中包含的分割字符时, 则会将该字符改为\0 字符,当连续出现多个时只替换第一个为\0。
参数:

  • str:指向欲分割的字符串
  • delim:为分割字符串中包含的所有字符

返回值

  • 成功:分割后字符串首地址
  • 失败:NULL

注意:

  • 在第一次调用时:strtok()必需给予参数s字符串
  • 往后的调用则将参数s设置成NULL,每次调用成功则返回指向被分割出片段的指针
int main(){
    char a[100] = "abc-efg-hijk-lmn";
    char *s = strtok(a, "-");  //将"-”分割的子串取出
    while (s != NULL){
        printf("%s\n", s);
        s = strtok(NULL, "-");
        printf("view the s: %s\n", s);
    }
}

字符串知识点完整代码:

int main(){
    //字符串的复制  strcpy
    /*char *src = "hello";

    char dst[10];
    strcpy(dst, src);
    printf("%s\n", dst);  //复制

    char a[4];
    char b[4];
    strcpy(b, "hello");
    printf("b: %s\n", b);
    printf("a: %s\n", a);*/

    /*char *src = "hello\0world";
    char dst[10];
    //char *dst;
    //dst = malloc(10);
    memset(dst, 'A', 10);
    printf("dst:%s\n", dst);    //AAAAAAAAAA
    strncpy(dst, src, 3);
    printf("dst: %s\n", dst);   //helAAAAAAA

    char *src1 = "hello";
    memset(dst, 0, 10);
    strncpy(dst, src, sizeof(dst)-1);
    printf("dst:%s\n", dst);    //hello

    int i;
    for (i=0; i<10; i++)
        printf("view the i: %d dst[i]: %c\n", i, dst[i]);
    printf("\n");*/


    //字符串的拼接 strcat
    /*char dst[20];
    memset(dst, 0, sizeof(dst));
    char *src = "he\0llo";
    strcpy(dst, "world");
    strcat(dst, src);
    printf("dst: %s\n", dst);  //worldhe */

    //字符串的对比
    //strcmp函数
    /*char *s1 = "hello world";
    char *s2 = "hello";
    printf("%d\n", strcmp(s2, s1));   //-1

    char *stus[] = {"zhangsan", "lisi", "wangwu", "liusan", "huangsan"};
    int i;
    for (i=0; i<3; i++){
        if (strcmp(stus[i], "lisi") == 0)
            printf("hello, lisi: %d\n", i);   //1
    }
    printf("view the data strncmp: %d\n", strncmp(s1, s2, 5));   //0 */


    //strstr函数  查找字符串内部是否存在某个元素
    /*char *stus[] = {"zhangsan", "lisi", "wangwu", "liusan", "huangsan"};
    int i;
    char *p;
    for (i=0; i<5; i++){
        //找出名字中带san的学生
        if (p = strstr(stus[i], "san")){
            printf("view the data, i: %d, stus[i]: %s\n", i, stus[i]);
            printf("%p, %p\n", stus[i], p);
        }
    }*/


    //字符串的分割  strtok
    char data[] = {"##name=zhangsan;score=99.5;age=10##"};
    //第一步用;分割
    char *p;
    int n = 0;
    int len;
    p = strtok(data, ";");
    printf("view the n: %s\n", p);  //##name=zhangsan

    len = strlen(p);
    while (*p != '=' && n<=len){
        printf("n:%d\n", n);
        p++;
        n++;
    }
    if (n <= len){
        p++;
        char name[10];
        memset(name, 0, 10);
        strcpy(name, p);
        printf("view the n: %d, len: %d, name: %s\n", n, len, name);  //zhangsan
    }


    //第二次对剩下的数据使用;分割
    char name[10];
    int age;
    float score;
    while (p = strtok(NULL, ";")){
        char *tmp = p;
        printf("%s\n", p);
        len = strlen(p);
        n = 0;
        while (*p != '=' && n<=len){
            p++;
            n++;
        }
        printf("view the data p: %c", p);
        if (n <= len){
            p++;
            if (strstr(tmp, "age=") != NULL){
                age = atoi(p);
                printf("age: %d\n", age);
            }
            else if (strstr (tmp, "score=") != NULL){
                score = atof(p);
                printf("score: %f\n", score);
            }
        }
    }

    p = strtok(NULL, ";");
    printf("view the strtok p: %s\n", p);
    len = strlen(p);
    n = 0;
    while (*p != '=' && n<=len){
        p++;
        n++;
    }
    if (n <= len){
        p++;
        int age;
        age = atoi(p);  //18
        printf("age: %d\n", age);
    }

    p = strtok(NULL, ";");
    printf("+++++ %s\n", p);
    len = strlen(p);
    n = 0;
    while (*p != '=' && n<=len){
        p++;
        n++;
    }
    if (n <= len){
        p++;
        float score;
        score = atof(p);
        printf("score: %f\n", score);
    }

    return 0;
}

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

GB50149-2010电气装置安装工程母线装置施工及验收规范

为了确保强硬钢丝绳金属封闭体绝缘金属封闭母线、绝缘子、硬件、穿墙套管等设备母线的安装质量,加快安装技术的进步,和确保设备的安全运行,使该规范。 本规范适用于总线设备安装了750 kv及以下的T范围施工和验收。 母线的安装应按照批准的设计文件施工。 设备和设备运输、储…

python:并发编程(二十五)

前言 本文将和大家一起探讨python并发编程的实际项目&#xff1a;win图形界面应用&#xff08;篇七&#xff0c;共八篇&#xff09;&#xff0c;系列文章将会从零开始构建项目&#xff0c;并逐渐完善项目&#xff0c;最终将项目打造成适用于高并发场景的应用。 本文为python并…

postman 文档、导出json脚本 导出响应数据 response ,showdoc导入postman json脚本 导出为文档word或markdown

生成文档 Collections中 选中文件夹 - ... (文件夹 功能小按钮) - view documentation : 保存响应数据 Response&#xff1a;&#xff08;如果导出接口数据&#xff0c;会同步导出响应数据&#xff09; 请求接口后&#xff0c;点击下方 Save as Example 可以保存响应数…

机器学习day20(前向传播的向量化代码,矩阵乘法)

前向传播的循环代码与向量化代码的对比 把X、B写作二维数组&#xff0c;即矩阵左边的for循环就可以用右边的np.matmul来实现matmul是numpy执行矩阵乘法的一种方式注意&#xff1a;此时所有的变量&#xff08;X、W、B、Z、A_out&#xff09;都是二维数组&#xff0c;即矩阵 向…

基础排序算法【归并排序+非递归版本+边界修正】

基础排序算法【归并排序非递归版本边界修正】 Ⅰ.归并排序(递归版本)①.分割②.归并③.拷贝 Ⅱ.非递归版本Ⅲ.边界修正 Ⅰ.归并排序(递归版本) 递归排序&#xff0c;采用的是分治法。分成子问题来处理。先让序列不断分割成子序列&#xff0c;当子序列有序后再合并。 对于一段…

Yolov5-Face 原理解析及算法解析

YOLOv5-Face 文章目录 YOLOv5-Face1. 为什么人脸检测 一般检测&#xff1f;1.1 YOLOv5Face人脸检测1.2 YOLOv5Face Landmark 2.YOLOv5Face的设计目标和主要贡献2.1 设计目标2.2 主要贡献 3. YOLOv5Face架构3.1 模型架构3.1.1 模型示意图3.1.2 CBS模块3.1.3 Head输出3.1.4 stem…

202320读书笔记|《宋词》——竹杖芒鞋轻胜马,谁怕?一蓑烟雨任平生

202320读书笔记&#xff5c;《宋词》——竹杖芒鞋轻胜马&#xff0c;谁怕&#xff1f;一蓑烟雨任平生 《宋词》韩震主编&#xff0c;偶然从书友那加入书架的书。宋词挺喜欢李清照的词以及知否的《菩萨蛮》。诗集&#xff0c;词&#xff0c;俳句&#xff0c;短歌我都很喜欢&…

工欲善其事,必先利其器-基于ubuntu18.04 VScode开发100ASK-ESP32

点击上方“嵌入式应用研究院”&#xff0c;选择“置顶/星标公众号” 干货福利&#xff0c;第一时间送达&#xff01; 来源 | 嵌入式应用研究院 整理&排版 | 嵌入式应用研究院 前面我们基于ubuntu环境搭建了esp-idf的开发环境&#xff0c;它也是为了接下来基于VSCode来开发1…

【openGauss基本概念】---快速入门

【openGauss简单使用】---快速入门 &#x1f53b; 一、基本概念&#x1f530; 1.1 openGauss&#x1f530; 1.2 数据库&#xff08;Database&#xff09;&#x1f530; 1.3 数据块&#xff08;Block&#xff09;&#x1f530; 1.4 行&#xff08;Row&#xff09;&#x1f530; …

【MySQL数据库】主从复制与读写分离

目录 一、读写分离1.1概述1.2为什么要读写分离呢&#xff1f;1.3什么时候要读写分离&#xff1f; 1.4主从复制与读写分离1.5mtsql支持的复制类型1.6主从复制工作流程1.7主从复制原理 二、主从复制实战 一、读写分离 1.1概述 读写分离&#xff0c;基本的原理是让主数据库处理事…

React从入门到实战 -组件的三大核心属性(2)props

文章目录 基本使用对props进行限制类式组件中的构造器 基本使用 // 定义组件class MyComponent extends React.Component{render(){return (<ul><li>姓名&#xff1a;{this.props.name}</li><li>年龄&#xff1a;{this.props.age}</li><li>…

【开源与项目实战:开源实战】85 | 开源实战四(中):剖析Spring框架中用来支持扩展的两种设计模式

上一节课中&#xff0c;我们学习了 Spring 框架背后蕴藏的一些经典设计思想&#xff0c;比如约定优于配置、低侵入松耦合、模块化轻量级等等。我们可以将这些设计思想借鉴到其他框架开发中&#xff0c;在大的设计层面提高框架的代码质量。这也是我们在专栏中讲解这部分内容的原…

MongoDB负载均衡集群(第8章节选)

MongoDB自身可组成分片加复制的集群&#xff0c;在这个集群的前端加上负载均衡器&#xff08;比如HAProxmy Keepalived&#xff09;&#xff0c;就可组建成一个无单点故障、十分完美的高可用负载均衡集群&#xff08;如图8-1所示&#xff09;。 图8- 1 整个MongDB高可用体系结…

基于java+swing+mysql飞机票预订系统

基于javaswingmysql飞机票预订系统 一、系统介绍二、功能展示1.项目内容2.项目骨架3.数据库表4.注册窗口5.登录窗口6、用户-主窗口7、用户-查询航班8.用户--订票8.用户--取票9.管理员-所有航班信息10.管理员-添加航班11.用户信息12.订票状态 四、其它1.其他系统实现五.获取源码…

路径规划-DWA算法(C++实现)

1、简单介绍 DWA算法&#xff08;dynamic window approach&#xff09;&#xff0c;其原理主要是在速度空间&#xff08;v,w&#xff09;中采样多组速度&#xff0c;并模拟出这些速度在一定时间内的运动轨迹&#xff0c;并通过评价函数对这些轨迹进行评价(其中包括距离障碍物距…

【学习笔记】 科目一之概念篇

【学习笔记】 科目一之概念篇 概念题方法 1&#xff09;抓重点&#xff1a;科目一设计知识范围太广&#xff0c;不要妄想所有知识点都复习到&#xff0c;这是不可能的&#xff0c;我们的目标是45分几个而不是考高分&#xff0c;复习时间有限&#xff0c;所以要学会抓重点&…

图片是如何生成的--图像生成模型(GAN、VAE、扩散模型)简介

目录 1.GAN 2.AutoEncoder及其变种&#xff1a;AE/DAE/VAE/VQVAE 2.1 AE&#xff1a; 2.2 DAE&#xff1a;Denoising AutoEncoder 2.3 VAE&#xff1a;Variational AutoEncoder 2.4 VQVAE&#xff1a;Vector-quantised Variational AutoEncoder 3. 扩散模型 3.1 扩散…

【openGauss简单数据管理】--快速入门

【openGauss简单数据管理】--快速入门 &#x1f53b; 一、openGauss数据库管理&#x1f530; 1.1 连接openGauss数据库&#x1f530; 1.2 创建数据库&#x1f530; 1.3 查看数据库和切换数据库&#x1f530; 1.4 修改数据库&#x1f530; 1.5 删除数据库&#x1f530; 1.6 启停…

【QQ界面展示-实现自动回复 Objective-C语言】

一、刚才咱们监听键盘弹出事件,是怎么监听的, 1.监听键盘弹出事件的步骤 1)首先,在控制器的viewDidLoad方法中,创建一个NotificationCenter对象啊 2)通过center,让当前控制器的这个方法,监听这个通知, 3)然后,我们在这个通知里面,获取到键盘的Y值, 4)对我们的…

Rust 原始类型之数组array内置方法

目录 数组 array 声明 访问 引用 Reference 切片 Slice 方法 题目实例 数组 array 在 Rust 中&#xff0c;数组是一种固定大小的数据结构&#xff0c;用于存储具有相同数据类型的元素的有序集合。 “固定大小”是指数组中的元素的类型和数量确定&#xff0c;也就确定了…