【lesson53】线程控制

文章目录

  • 线程控制

线程控制

线程创建
代码：
在这里插入图片描述
运行代码：
在这里插入图片描述
强调一点，线程和进程不一样，进程有父进程的概念，但在线程组里面，所有的线程都是对等关系。
在这里插入图片描述
错误检查:

  • 传统的一些函数是，成功返回0，失败返回-1，并且对全局变量errno赋值以指示错误。
  • pthreads函数出错时不会设置全局变量errno（而大部分其他POSIX函数会这样做）。而是将错误代码通过返回值返回
  • pthreads同样也提供了线程内的errno变量，以支持其它使用errno的代码。对于pthreads函数的错误，建议通过返回值业判定，因为读取返回值要比读取线程内的errno变量的开销更小

进程ID和线程ID
在Linux中，目前的线程实现是Native POSIX Thread Libaray,简称NPTL。在这种实现下，线程又被称为轻量级进程(Light Weighted Process),每一个用户态的线程，在内核中都对应一个调度实体，也拥有自己的进程描述符(task_struct结构体)。
没有线程之前，一个进程对应内核里的一个进程描述符，对应一个进程ID。但是引入线程概念之后，情况发生了变化，一个用户进程下管辖N个用户态线程，每个线程作为一个独立的调度实体在内核态都有自己的进程描述符，进程和内核的描述符一下子就变成了1：N关系，POSIX标准又要求进程内的所有线程调用
getpid函数时返回相同的进程ID，如何解决上述问题呢？
Linux内核引入了线程组的概念。
在这里插入图片描述
多线程的进程，又被称为线程组，线程组内的每一个线程在内核之中都存在一个进程描述符（task_struct）与之对应。进程描述符结构体中的pid，表面上看对应的是进程ID，其实不然，它对应的是线程ID;进程描述
符中的tgid，含义是Thread Group ID,该值对应的是用户层面的进程ID
在这里插入图片描述

线程异常
我们之前学到线程一旦异常那么整个进程都会退出，那么真的是如此吗？
演示：
代码

#include <iostream>
#include <pthread.h>
#include <unistd.h>void *threadRoutine(void *arg)
{const std::string name = (char *)arg;while (true){std::cout << name << " pid:" << getpid() << "\n"<< std::endl;int a = 100;a /= 0;//除0错误sleep(1);}return nullptr;
}
int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");while (true){std::cout << "main thread pid:" << getpid() << std::endl;sleep(3);}return 0;
}

运行代码：
在这里插入图片描述
我们发现线程一旦异常确实会影响到整个进程。

结论：
1.线程谁先运行与调度器相关
2.随便哪个线程一旦异常，都可能导致整个进程整体退出
3.线程在创建并执行的时候，线程也需要进行等待的，如果主线程不等待，也会引起类似于僵尸进程问题，导致内存泄漏。

线程等待
已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。
创建新的线程不会复用刚才退出线程的地址空间。
在这里插入图片描述
调用该函数的线程将挂起等待,直到id为thread的线程终止。thread线程以不同的方法终止,通过pthread_join得到的终止状态是不同的，总结如下:

  1. 如果thread线程通过return返回,value_ ptr所指向的单元里存放的是thread线程函数的返回值。
  2. 如果thread线程被别的线程调用pthread_ cancel异常终掉,value_ ptr所指向的单元里存放的是常数PTHREAD_CANCELED。
  3. 如果thread线程是自己调用pthread_exit终止的,value_ptr所指向的单元存放的是传给pthread_exit的参数。
  4. 如果对thread线程的终止状态不感兴趣,可以传NULL给value_ ptr参数。

在这里插入图片描述

在这里插入图片描述
参数解释：
thread：线程id
retval：输出型参数，下面再解释用处
pthread_join默认阻塞等待。
代码：

#include <iostream>
#include <pthread.h>
#include <unistd.h>void *threadRoutine(void *arg)
{const std::string name = (char *)arg;int i = 0;while (true){std::cout << name << "runing....." << std::endl;sleep(1);if(i++ == 10){break;}}std::cout << "new thread quit....." << std::endl;return nullptr;
}
int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");pthread_join(tid,nullptr);std::cout << "main thread wait done .... main quit!" << std::endl;return 0;
}

运行代码：
在这里插入图片描述
我们知道pthread_create里面有一个回调函数，而回调函数里面有一个返回值我们之前一直返回nullptr
在这里插入图片描述
这个返回值，一般是给主线程的，那么主线程该如何获取到？用pthread_join。
在这里插入图片描述
pthread_join的第二个参数，是输出型参数，用来获取放回值的。
代码：

#include <iostream>
#include <pthread.h>
#include <unistd.h>void *threadRoutine(void *arg)
{const std::string name = (char *)arg;int i = 0;while (true){std::cout << name << "runing....." << std::endl;sleep(1);if (i++ == 10){break;}}std::cout << "new thread quit....." << std::endl;return (void *)10;
}
int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");void *ret = nullptr;pthread_join(tid, &ret);std::cout << "ret: " << (long long)ret << std::endl;std::cout << "main thread wait done .... main quit!" << std::endl;return 0;
}

我们运行的时候会这样
我们只要在g++后面加-fpermissive即可

g++ -o mythread mythread.cc -std=c++11 -lpthread -fpermissive

在这里插入图片描述
再运行代码：
在这里插入图片描述
可以看到，我们成功获取到了返回值。
我们不仅仅只能返回变量，我们还能返回其它内容。
代码：

#include <iostream>
#include <pthread.h>
#include <unistd.h>void *threadRoutine(void *arg)
{const std::string name = (char *)arg;int i = 0;int *data = new int[10];while (true){std::cout << name << "runing....." << std::endl;sleep(1);data[i] = i;if (i++ == 10){break;}}std::cout << "new thread quit....." << std::endl;return (void *)data;
}
int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");void *ret = nullptr;pthread_join(tid, &ret);int *data = (int *)ret;for (int i = 0; i < 10; i++){std::cout << data[i] << " ";}std::cout << std::endl;std::cout << "main thread wait done .... main quit!" << std::endl;return 0;
}

运行结果：
在这里插入图片描述
线程终止
如果需要只终止某个线程而不终止整个进程,可以有三种方法:

  1. 从线程函数return。这种方法对主线程不适用,从main函数return相当于调用exit。
  2. 线程可以调用pthread_ exit终止自己。
  3. 一个线程可以调用pthread_ cancel终止同一进程中的另一个线程。
    能不能用exit终止线程呢？

代码：

#include <iostream>
#include <pthread.h>
#include <unistd.h>void *threadRoutine(void *arg)
{const std::string name = (char *)arg;int i = 0;int *data = new int[10];while (true){std::cout << name << "runing....." << std::endl;sleep(1);data[i] = i;if (i++ == 10){break;}}std::cout << "new thread quit....." << std::endl;exit(10);return (void *)data;
}
int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");void *ret = nullptr;pthread_join(tid, &ret);int *data = (int *)ret;for (int i = 0; i < 10; i++){std::cout << data[i] << " ";}std::cout << std::endl;std::cout << "main thread wait done .... main quit!" << std::endl;return 0;
}

运行结果：
在这里插入图片描述
我们发现整个进程都被终止了，因为exit是终止进程的，绝对不要用exit终止线程。
那么我们如何终止新线程而不影响main线程呢？
pthread_exit()OS提供的终止线程的函数
在这里插入图片描述
在这里插入图片描述
参数retval就是之前的返回值。
代码

#include <iostream>
#include <pthread.h>
#include <unistd.h>void *threadRoutine(void *arg)
{const std::string name = (char *)arg;int i = 0;int *data = new int[10];while (true){std::cout << name << "runing....." << std::endl;sleep(1);data[i] = i;if (i++ == 10){break;}}std::cout << "new thread quit....." << std::endl;pthread_exit((void*)data);
}
int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");void *ret = nullptr;pthread_join(tid, &ret);int *data = (int *)ret;for (int i = 0; i < 10; i++){std::cout << data[i] << " ";}std::cout << std::endl;std::cout << "main thread wait done .... main quit!" << std::endl;return 0;
}

运行结果：
在这里插入图片描述
我们看到线程终止成功。

线程取消
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
代码：

#include <iostream>
#include <pthread.h>
#include <unistd.h>void *threadRoutine(void *arg)
{const std::string name = (char *)arg;while (true){std::cout << name << "runing....." << std::endl;sleep(1);}std::cout << "new thread quit....." << std::endl;
}
int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");int count = 3;while (true){std::cout << "main thread pid:" << getpid() << std::endl;if(count++ > 5) break;sleep(2);}pthread_cancel(tid);std::cout << "pthread cancle tid: " << tid << std::endl; void *ret = nullptr;pthread_join(tid, &ret);std::cout << "ret: " << (long long)ret << std::endl;std::cout << "main thread wait done .... main quit!" << std::endl;sleep(5);return 0;
}

运行结果：
在这里插入图片描述
我们看到最后main线程确实等待了5秒
在这里插入图片描述
然后退出了。
我们看到其中tid为啥这么大呢？之后再讲解。
而我们看到线程被取消，我们join的时候，退出码是-1.
而-1其实是：
在这里插入图片描述

线程ID的探索
我们之前看到线程ID是一个很大的值
格式化输出线程ID：
代码：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <cstdio>void *threadRoutine(void *arg)
{const std::string name = (char *)arg;while (true){std::cout << name << "runing....." << std::endl;sleep(1);}std::cout << "new thread quit....." << std::endl;
}
int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");printf("%u,%p\n",tid,tid);int count = 3;while (true){std::cout << "main thread pid:" << getpid() << std::endl;if(count++ > 5) break;sleep(2);}pthread_cancel(tid);std::cout << "pthread cancle tid: " << tid << std::endl; void *ret = nullptr;pthread_join(tid, &ret);std::cout << "ret: " << (long long)ret << std::endl;std::cout << "main thread wait done .... main quit!" << std::endl;sleep(5);return 0;
}

运行结果：
在这里插入图片描述
我们看到线程ID值很大，tid的本质是一个地址。
为什么tid不用Linux中的LWP呢？
因为目前用的不是Linux自带的创建线程的接口，我们用的是pthread库中的接口。
我们知道线程共享进程的地址空间
在这里插入图片描述
但是线程有自己独立的栈结构，那么如何保证栈区是每一个线程独占的呢？---->原本的栈给main线程使用，而其余线程把共享区当做栈区。所以每个线程的tid就是自己栈区的起始地址
在这里插入图片描述
见一见
在这里插入图片描述
pthread库时通过clone做到上面的那点。
在这里插入图片描述
那么我们如何获取线程的id呢？
在这里插入图片描述
代码：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <cstdio>void *threadRoutine(void *arg)
{const std::string name = (char *)arg;while (true){std::cout << name << "runing..... id: " << pthread_self() << std::endl;sleep(1);}std::cout << "new thread quit....." << std::endl;
}
int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");int count = 3;while (true){std::cout << "main thread id:" << pthread_self() << std::endl;if(count++ > 5) break;sleep(2);}void *ret = nullptr;pthread_join(tid, &ret);std::cout << "ret: " << (long long)ret << std::endl;std::cout << "main thread wait done .... main quit!" << std::endl;sleep(5);return 0;
}

运行代码：
在这里插入图片描述
我们看到我们获取到了不同的线程id

大部分线程的代码是共享的！
一个小实验：
代码：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <cstdio>int g_val = 0;
void *threadRoutine(void *arg)
{const std::string name = (char *)arg;while(true){std::cout << name << " g_val: " << g_val << " &g_val" << &g_val << std::endl;g_val++;sleep(1);}}
int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");while(true){std::cout << "main thread g_val: " << g_val << " &g_val" << &g_val << std::endl;sleep(1);}return 0;
}

运行结果：
在这里插入图片描述
我们看到g_val被大家所共享，大家都可以看到g_val，一个线程对其进程改变，其它线程都看的到。
那么如果线程想要自己是私有的变量呢？该如何？
只要在变量前加__thread即可。
代码：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <cstdio>__thread int g_val = 0;
void *threadRoutine(void *arg)
{while(true){std::cout << (char*)arg << ": "<< g_val << " &: " << &g_val << std::endl;g_val++;sleep(1);}
}
int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");while(true){std::cout << "main thread: " << g_val << " &: " << &g_val << std::endl;sleep(1);}return 0;
}

运行代码：
在这里插入图片描述
这里运行的时候是并行执行的所以会看不清，但是我们也能看到，两个变量的地址不一样的。

__thread：修饰全局变量，带来的结果就是让每一个线程各自拥有一个全局变量---->线程的就不存储。

我们之前学过进程替换，如果线程进行进程替换会如何？
代码：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <cstdio>__thread int g_val = 0;
void *threadRoutine(void *arg)
{execl("/bin/ls","ls",nullptr);while(true){std::cout << (char*)arg << ": "<< g_val << " &: " << &g_val << std::endl;g_val++;sleep(1);}}
int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");while(true){std::cout << "main thread: " << g_val << " &: " << &g_val << std::endl;sleep(1);}return 0;
}

运行结果：
在这里插入图片描述
我们看到ls确实被执行了，但是整个进程的代码都被替换掉了。

分离线程
默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。
如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。

测试代码：

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <cstdio>
#include <cerrno>
#include <cstring>__thread int g_val = 0;
void *threadRoutine(void *arg)
{pthread_detach(pthread_self());while(true){std::cout << (char*)arg << ": "<< g_val << " &: " << &g_val << std::endl;g_val++;sleep(1);}
}
int main()
{pthread_t tid;pthread_create(&tid, nullptr, threadRoutine, (void *)"thread 1");while(true){std::cout << "main thread: " << g_val << " &: " << &g_val << std::endl;sleep(1);break;}int n = pthread_join(tid,nullptr);std::cout << "n:" << n << " errstring: " << strerror(n) << std::endl;return 0;
}

运行结果：
在这里插入图片描述
我们看到join异常进程直接退出。

所以线程分离后线程异常也会影响整个进程

C++语言提供的线程，而语言级别的线程库必须调用原生线程库---->本质是对原生线程库的封装
代码：
在这里插入图片描述
运行：
在这里插入图片描述
进程线程间的互斥相关背景概念
临界资源：多线程执行流共享的资源就叫做临界资源
临界区：每个线程内部，访问临界自娱的代码，就叫做临界区
互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
原子性（后面讨论如何实现）：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

如果多个线程访问同一个全局变量，并对它进行数据计算，多线程会互相影响吗？
测试代码：
抢票代码

#include <iostream>
#include <thread>
#include <pthread.h>
#include <unistd.h>
#include <cstdio>
#include <cerrno>
#include <cstring>int tickets = 10000;
void *GetTickets(void *args)
{while (true){if (tickets > 0){usleep(1000);printf("%p : %d\n", pthread_self(), tickets);tickets--;}else{break;}}return nullptr;
}int main()
{pthread_t t1;pthread_t t2;pthread_t t3;pthread_create(&t1, nullptr, GetTickets, nullptr);pthread_create(&t2, nullptr, GetTickets, nullptr);pthread_create(&t3, nullptr, GetTickets, nullptr);pthread_join(t1, nullptr);pthread_join(t2, nullptr);pthread_join(t3, nullptr);return 0;
}

运行结果：
在这里插入图片描述
我们发现票抢到-1了，这肯定是错的！
每次运行的结果都不一定一样：
在这里插入图片描述
所以tickets在并发访问的时候，导致了我们数据不一致的问题。之后再解决这个歌问题。

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

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

相关文章

算法--数论二

算法--数论二

这里写目录标题 高斯消元高斯消元求线性方程组用途高斯消元的数学思想例题代码 二级目录 一级目录二级目录二级目录二级目录 一级目录二级目录二级目录二级目录 一级目录二级目录二级目录二级目录 一级目录二级目录二级目录二级目录 高斯消元 高斯消元求线性方程组 用途 这个…
阅读更多...
Rust - 切片Slice

Rust - 切片Slice

Slice类型 Slice数据类型没有所有权&#xff0c;slice允许我们引用集合中一段连续的元素序列而不用引用整个集合。字符串slice(string slice) 是String中 一部分值的引用。如下述代码示例&#xff0c;不是对整个String的引用而是对部分String的引用&#xff1a; fn main() {l…
阅读更多...
Android矩阵Matrix动画缩放Bitmap移动手指触点到ImageView中心位置，Kotlin

Android矩阵Matrix动画缩放Bitmap移动手指触点到ImageView中心位置，Kotlin

Android矩阵Matrix动画缩放Bitmap移动手指触点到ImageView中心位置&#xff0c;Kotlin 借鉴 Android双指缩放ScaleGestureDetector检测放大因子大图移动到双指中心点ImageView区域中心&#xff0c;Kotlin&#xff08;2&#xff09;-CSDN博客 在此基础上实现手指在屏幕上点击后&…
阅读更多...
模拟算法总结（Java）

模拟算法总结（Java）

目录 模拟算法概述 练习 练习1&#xff1a;替换所有的问号 练习2&#xff1a;提莫攻击 练习3&#xff1a;Z字形变换 模拟算法概述 模拟&#xff1a;根据题目要求的实现过程进行编程模拟&#xff0c;即题目要求什么就实现什么 解决这类题目&#xff0c;需要&#xff1a; 1…
阅读更多...
【Linux取经路】文件系统之被打开的文件——文件描述符的引入

【Linux取经路】文件系统之被打开的文件——文件描述符的引入

文章目录 一、明确基本共识二、C语言文件接口回顾2.1 文件的打开操作2.2 文件的读取写入操作2.3 三个标准输入输出流 三、文件有关的系统调用3.1 open3.1.1 比特位级别的标志位传递方式 3.2 write3.2.1 模拟实现 w 选项3.2.2 模拟实现 a 选项 3.3 read 四、访问文件的本质4.1 再…
阅读更多...
多线程面试题汇总

多线程面试题汇总

多线程面试题汇总 一、多线程1、线程的生命周期2、线程的创建&#xff08;函数创建&#xff09;3、线程的创建&#xff08;使用类&#xff09;4、守护线程 二、全局解释器锁1、使用单线程实现累加到5000000002、使用多线程实现累加到5000000003、总结 三、线程安全1、多线程之数…
阅读更多...
2024春节联欢晚会刘谦魔术分析

2024春节联欢晚会刘谦魔术分析

春晚已经越来越拉胯了&#xff0c;看着节目单没一个能打的&#xff0c;本来想说&#xff1a;办不起&#xff0c;就别办呗。 没想到第二天刘谦的魔术以一种很奇特的姿势火起来了&#xff0c;干脆蹭个热度&#xff0c;分析下魔术的原理。 魔术1 这个不算什么新奇的节目&#xf…
阅读更多...
leetcode刷题--贪心算法

leetcode刷题--贪心算法

七. 贪心算法 文章目录 七. 贪心算法1. 605 种花问题2. 121 买卖股票的最佳时机3. 561 数组拆分4. 455 分发饼干5. 575 分糖果6. 135 分发糖果7. 409 最长回文串8. 621 任务调度器9. 179 最大数10. 56 合并区间11. 57 插入区间13. 452 用最少数量的箭引爆气球14. 435 无重叠区间…
阅读更多...
Spring Boot3整合Redis

Spring Boot3整合Redis

⛰️个人主页: 蒾酒 &#x1f525;系列专栏&#xff1a;《spring boot实战》 &#x1f30a;山高路远&#xff0c;行路漫漫&#xff0c;终有归途。 目录 前置条件 1.导依赖 2.配置连接信息以及连接池参数 3.配置序列化方式 4.编写测试 前置条件 已经初始化好一个spr…
阅读更多...
STM32——OLED菜单(二级菜单)

STM32——OLED菜单(二级菜单)

文章目录 一.补充二. 二级菜单代码 简介&#xff1a;首先在我的51 I2C里面有OLED详细讲解&#xff0c;本期代码从51OLED基础上移植过来的&#xff0c;可以先看完那篇文章&#xff0c;在看这个&#xff0c;然后按键我是用的定时器扫描不会堵塞程序,可以翻开我的文章有单独的定时…
阅读更多...
Vulnhub靶机：DC6

Vulnhub靶机：DC6

一、介绍 运行环境&#xff1a;Virtualbox 攻击机&#xff1a;kali&#xff08;10.0.2.15&#xff09; 靶机&#xff1a;DC6&#xff08;10.0.2.59&#xff09; 目标&#xff1a;获取靶机root权限和flag 靶机下载地址&#xff1a;https://www.vulnhub.com/entry/dc-6,315/…
阅读更多...
《MySQL 简易速速上手小册》第9章：高级 MySQL 特性和技巧（2024 最新版）

《MySQL 简易速速上手小册》第9章：高级 MySQL 特性和技巧（2024 最新版）

文章目录 9.1 使用存储过程和触发器9.1.1 基础知识9.1.2 重点案例&#xff1a;使用 Python 调用存储过程实现用户注册9.1.3 拓展案例 1&#xff1a;利用触发器自动记录数据更改历史9.1.4 拓展案例 2&#xff1a;使用 Python 和触发器实现数据完整性检查 9.2 管理和查询 JSON 数…
阅读更多...
[网鼎杯 2020 朱雀组]phpweb

[网鼎杯 2020 朱雀组]phpweb

抓包发现两个参数&#xff0c;结合报文返回的warning猜测两个参数一个传函数名&#xff0c;另一个传函数参数 尝试直接system(ls /)&#xff0c;发现被过滤了 file_get_contents获取index.php的源码&#xff0c;发现可以反序列化实现RCE 这里复现的时候不知道为什么显示不全…
阅读更多...
力扣例题----二叉树

力扣例题----二叉树

文章目录 1. 100.相同的树2. 572. 另一颗树的子树3. 266.翻转二叉树4. LCR 175.计算二叉树的深度5. 110.平衡二叉树6. 101. 对称二叉树7. 牛客题目&#xff1a;KY11 二叉树遍历8. 102.二叉树的层序遍历9. 236.二叉树的最近公共祖先10. 105.根据前序和中序构造一棵二叉树11. 106…
阅读更多...
python 人脸检测器

python 人脸检测器

import cv2# 加载人脸检测器 关键文件 haarcascade_frontalface_default.xml face_cascade cv2.CascadeClassifier(haarcascade_frontalface_default.xml)# 读取图像 分析图片 ren4.png image cv2.imread(ren4.png) gray cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)# 进行人脸…
阅读更多...
COM初体验——新建文档并写入内容。

COM初体验——新建文档并写入内容。

我想在程序里和Word交互。老师跟我说不要学COM&#xff0c;因为它已经过时了。但是我不想再把代码移植到C#上面&#xff0c;然后用VSTO——已经用了std::unordered_set&#xff01;因为我使用了Copilot&#xff0c;结合我的思考&#xff0c;写了下面的代码&#xff1a; #impor…
阅读更多...
17.JS中的object、map和weakMap

17.JS中的object、map和weakMap

1.object和map的区别 2.weakMap和map的区别 &#xff08;1&#xff09;Map本质上就是键值对的集合&#xff0c;但是普通的Object中的键值对中的键只能是字符串。而ES6提供的Map数据结构类似于对象&#xff0c;但是它的键不限制范围&#xff0c;可以是任意类型&#xff0c;是一…
阅读更多...
【C++】友元、内部类和匿名对象

【C++】友元、内部类和匿名对象

&#x1f497;个人主页&#x1f497; ⭐个人专栏——C学习⭐ &#x1f4ab;点击关注&#x1f929;一起学习C语言&#x1f4af;&#x1f4ab; 目录 1. 友元 1.1 友元函数 1.2 友元类 2. 内部类 2.1 成员内部类 2.2 局部内部类 3. 匿名对象 3.1 基本概念 3.1 隐式转换 1…
阅读更多...
【Spring原理进阶】SpringMVC调用链＋JSP模板应用讲解

【Spring原理进阶】SpringMVC调用链＋JSP模板应用讲解

&#x1f389;&#x1f389;欢迎光临&#x1f389;&#x1f389; &#x1f3c5;我是苏泽&#xff0c;一位对技术充满热情的探索者和分享者。&#x1f680;&#x1f680; &#x1f31f;特别推荐给大家我的最新专栏《Spring 狂野之旅&#xff1a;底层原理高级进阶》 &#x1f680…
阅读更多...
机器学习入门--循环神经网络原理与实践

机器学习入门--循环神经网络原理与实践

循环神经网络 循环神经网络&#xff08;RNN&#xff09;是一种在序列数据上表现出色的人工神经网络。相比于传统前馈神经网络&#xff0c;RNN更加适合处理时间序列数据&#xff0c;如音频信号、自然语言和股票价格等。本文将介绍RNN的基本数学原理、使用PyTorch和Scikit-Learn…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023