【可变模板参数】

文章目录

  • 可变参数模板的概念
  • 可变参数模板的定义方式
  • 参数包的展开方式
      • 递归展开参数包
      • 逗号表达式展开参数包
  • STL容器中的emplace相关接口函数

可变参数模板的概念

可变参数模板是C++11新增的最强大的特性之一，它对参数高度泛化，能够让我们创建可以接受可变参数的函数模板和类模板。

  • 在C++11之前，类模板和函数模板中只能包含固定数量的模板参数，可变模板参数无疑是一个巨大的改进，但由于可变参数模板比较抽象，因此使用起来需要一定的技巧。
  • 在C++11之前其实也有可变参数的概念，比如printf函数就能够接收任意多个参数，但这是函数参数的可变参数，并不是模板的可变参数。

说明一下：本篇博客只讲解函数模板的可变参数。

可变参数模板的定义方式

函数的可变参数模板定义方式如下：

template<class …Args>
返回类型 函数名(Args… args)
{
  //函数体
}
例如：

template<class ...Args>
void ShowList(Args... args)
{}

说明一下：

  • 模板参数Args前面有省略号，代表它是一个可变模板参数，我们把带省略号的参数称为参数包，参数包里面可以包含0到N ( N ≥ 0 ) N(N\geq 0)N(N≥0)个模板参数，而args则是一个函数形参参数包。
  • 模板参数包Args和函数形参参数包args的名字可以任意指定，并不是说必须叫做Args和args。

现在调用ShowList函数时就可以传入任意多个参数了，并且这些参数可以是不同类型的。比如：

int main()
{ShowList();ShowList(1);ShowList(1, 'A');ShowList(1, 'A', string("hello"));return 0;
}

我们可以在函数模板中通过sizeof计算参数包中参数的个数。比如：

int main()
{ShowList();ShowList(1);ShowList(1, 'A');ShowList(1, 'A', string("hello"));return 0;
}

我们可以在函数模板中通过sizeof计算参数包中参数的个数。比如：

template<class ...Args>
void ShowList(Args... args)
{cout << sizeof...(args) << endl; //获取参数包中参数的个数
}

但是我们无法直接获取参数包中的每个参数，只能通过展开参数包的方式来获取，这是使用可变参数模板的一个主要特点，也是最大的难点。

特别注意，语法并不支持使用args[i]的方式来获取参数包中的参数。比如：

template<class ...Args>
void ShowList(Args... args)
{//错误示例：for (int i = 0; i < sizeof...(args); i++){cout << args[i] << " "; //打印参数包中的每个参数}cout << endl;
}

因此要获取参数包中的各个参数，只能通过展开参数包的方式来获取，一般我们会通过递归或逗号表达式来展开参数包。

参数包的展开方式

递归展开参数包

递归展开参数包的方式如下：

  • 给函数模板增加一个模板参数，这样就可以从接收到的参数包中分离出一个参数出来。
  • 在函数模板中递归调用该函数模板，调用时传入剩下的参数包。
  • 如此递归下去，每次分离出参数包中的一个参数，直到参数包中的所有参数都被取出来。

比如我们要打印调用函数时传入的各个参数，那么函数模板可以这样编写：

//展开函数
template<class T, class ...Args>
void ShowList(T value, Args... args)
{cout << value << " "; //打印分离出的第一个参数ShowList(args...);    //递归调用，将参数包继续向下传
}

这时我们面临的问题就是，如何终止函数的递归调用。

编写无参的递归终止函数

我们可以在刚才的基础上，再编写一个无参的递归终止函数，该函数的函数名与展开函数的函数名相同。如下

//递归终止函数
void ShowList()
{cout << endl;
}
//展开函数
template<class T, class ...Args>
void ShowList(T value, Args... args)
{cout << value << " "; //打印分离出的第一个参数ShowList(args...);    //递归调用，将参数包继续向下传
}

这样一来，当递归调用ShowList函数模板时，如果传入的参数包中参数的个数为0，那么就会匹配到这个无参的递归终止函数，这样就结束了递归。

  • 但如果外部调用ShowList函数时就没有传入参数，那么就会直接匹配到无参的递归终止函数。
  • 而我们本意是想让外部调用ShowList函数时匹配的都是函数模板，并不是让外部调用时直接匹配到这个递归终止函数

鉴于此，我们可以将展开函数和递归调用函数的函数名改为ShowListArg，然后重新编写一个ShowList函数模板，该函数模板的函数体中要做的就是调用ShowListArg函数展开参数包。比如：

//递归终止函数
void ShowListArg()
{cout << endl;
}
//展开函数
template<class T, class ...Args>
void ShowListArg(T value, Args... args)
{cout << value << " "; //打印传入的若干参数中的第一个参数ShowListArg(args...); //将剩下参数继续向下传
}
//供外部调用的函数
template<class ...Args>
void ShowList(Args... args)
{ShowListArg(args...);
}

这时无论外部调用时传入多少个参数，最终匹配到的都是同一个函数了。

编写带参的递归终止函数

除了编写无参的递归终止函数，也可以编写带参数的递归终止函数来终止递归，比如这里编写带一个参数的递归终止函数：

//递归终止函数
template<class T>
void ShowList(T&& t)
{cout << t << endl;
}
//展开函数
template<class T, class ...Args>
void ShowListArg(T value, Args... args)
{cout << value << " "; //打印传入的若干参数中的第一个参数ShowList(args...);    //将剩下参数继续向下传
}
//供外部调用的函数
template<class ...Args>
void ShowList(Args... args)
{ShowListArg(args...);
}

这样一来，在递归调用过程中，如果传入的参数包中参数的个数为1，那么就会匹配到这个递归终止函数，这样也就结束了递归。但是需要注意，这里的递归调用函数需要写成函数模板，因为我们并不知道最后一个参数是什么类型的。

但该方法有一个弊端就是，我们在调用ShowList函数时必须至少传入一个参数，否则就会报错。因为此时无论是调用递归终止函数还是展开函数，都需要至少传入一个参数。

判断参数包中参数的个数（不可行！）

既然我们可以通过sizeof计算出参数包中参数的个数，那我们能不能在ShowList函数中设置一个判断，当参数包中参数个数为0时就终止递归呢？比如：

//错误示例
template<class T, class ...Args>
void ShowList(T value, Args... args)
{cout << value << " "; //打印传入的若干参数中的第一个参数if (sizeof...(args) == 0){return;}ShowList(args...);    //将剩下参数继续向下传
}

这种方式是不可行的，原因如下：

  • 函数模板并不能调用，函数模板需要在编译时根据传入的实参类型进行推演，生成对应的函数，这个生成的函数才能够被调用。
  • 而这个推演过程是在编译时进行的，当推演到参数包args中参数个数为0时，还需要将当前函数推演完毕，这时就会继续推演传入0个参数时的ShowList函数，此时就会产生报错，因为ShowList函数要求至少传入一个参数。
  • 这里编写的if判断是在代码编译结束后，运行代码时才会所走的逻辑，也就是运行时逻辑，而函数模板的推演是一个编译时逻辑。

逗号表达式展开参数包

通过列表获取参数包中的参数

数组可以通过列表进行初始化，比如：

int a[] = {1,2,3,4}

除此之外，如果参数包中各个参数的类型都是整型，那么也可以把这个参数包放到列表当中初始化这个整型数组，此时参数包中参数就放到数组中了。比如：

//展开函数
template<class ...Args>
void ShowList(Args... args)
{int arr[] = { args... }; //列表初始化//打印参数包中的各个参数for (auto e : arr){cout << e << " ";}cout << endl;
}

这时调用ShowList函数时就可以传入多个整型参数了。比如：

int main()
{ShowList(1);ShowList(1, 2);ShowList(1, 2, 3);return 0;
}

但C++并不像Python这样的语言，C++规定一个容器中存储的数据类型必须是相同的，因此如果这样写的话，那么调用ShowList函数时传入的参数只能是整型的，并且还不能传入0个参数，因为数组的大小不能为0，因此我们还需要在此基础上借助逗号表达式来展开参数包。

通过逗号表达式展开参数包

虽然我们不能用不同类型的参数去初始化一个整型数组，但我们可以借助逗号表达式。

  • 逗号表达式会从左到右依次计算各个表达式，并且将最后一个表达式的值作为返回值进行返回。
  • 将逗号表达式的最后一个表达式设置为一个整型值，确保逗号表达式返回的是一个整型值。
  • 将处理参数包中参数的动作封装成一个函数，将该函数的调用作为逗号表达式的第一个表达式。

这样一来，在执行逗号表达式时就会先调用处理函数处理对应的参数，然后再将逗号表达式中的最后一个整型值作为返回值来初始化整型数组。比如：

//处理参数包中的每个参数
template<class T>
void PrintArg(const T& t)
{cout << t << " ";
}
//展开函数
template<class ...Args>
void ShowList(Args... args)
{int arr[] = { (PrintArg(args), 0)... }; //列表初始化+逗号表达式cout << endl;
}

说明一下：

  • 我们这里要做的就是打印参数包中的各个参数，因此处理函数当中要做的就是将传入的参数进行打印即可。
  • 可变参数的省略号需要加在逗号表达式外面，表示需要将逗号表达式展开，如果将省略号加在args的后面，那么参数包将会被展开后全部传入PrintArg函数，代码中的{(PrintArg(args), 0)…}将会展开成{(PrintArg(arg1), 0), (PrintArg(arg2), 0), (PrintArg(arg3), 0), etc…}。

这时调用ShowList函数时就可以传入多个不同类型的参数了，但调用时仍然不能传入0个参数，因为数组的大小不能为0，如果想要支持传入0个参数，也可以写一个无参的ShowList函数。比如：

//支持无参调用
void ShowList()
{cout << endl;
}
//处理函数
template<class T>
void PrintArg(const T& t)
{cout << t << " ";
}
//展开函数
template<class ...Args>
void ShowList(Args... args)
{int arr[] = { (PrintArg(args), 0)... }; //列表初始化+逗号表达式cout << endl;
}

实际上我们也可以不用逗号表达式，因为这里的问题就是初始化整型数组时必须用整数，那我们可以将处理函数的返回值设置为整型，然后用这个返回值去初始化整型数组也是可以的。比如：

//支持无参调用
void ShowList()
{cout << endl;
}
//处理函数
template<class T>
int PrintArg(const T& t)
{cout << t << " ";return 0;
}
//展开函数
template<class ...Args>
void ShowList(Args... args)
{int arr[] = { PrintArg(args)... }; //列表初始化cout << endl;
}

STL容器中的emplace相关接口函数

emplace版本的插入接口

C++11标准给STL中的容器增加emplace版本的插入接口，比如list容器的push_front、push_back和insert函数，都增加了对应的emplace_front、emplace_back和emplace函数。如下：
在这里插入图片描述
这些emplace版本的插入接口支持模板的可变参数，比如list容器的emplace_back函数的声明如下：
在这里插入图片描述
注意： emplace系列接口的可变模板参数类型都带有“&&”，这个表示的是万能引用，而不是右值引用。

emplace系列接口的使用方式

emplace系列接口的使用方式与容器原有的插入接口的使用方式类似，但又有一些不同之处。

以list容器的emplace_back和push_back为例：

  1. 调用push_back函数插入元素时，可以传入左值对象或者右值对象，也可以使用列表进行初始化。
  2. 调用emplace_back函数插入元素时，也可以传入左值对象或者右值对象，但不可以使用列表进行初始化。
  3. 除此之外，emplace系列接口最大的特点就是，插入元素时可以传入用于构造元素的参数包。
int main()
{list<pair<int, string>> mylist;pair<int, string> kv(10, "111");mylist.push_back(kv);                              //传左值mylist.push_back(pair<int, string>(20, "222"));    //传右值mylist.push_back({ 30, "333" });                   //列表初始化mylist.emplace_back(kv);                           //传左值mylist.emplace_back(pair<int, string>(40, "444")); //传右值mylist.emplace_back(50, "555");                    //传参数包return 0;
}

emplace系列接口的工作流程

  1. 先通过空间配置器为新结点获取一块内存空间，注意这里只会开辟空间，不会自动调用构造函数对这块空间进行初始化。
  2. 然后调用allocator_traits::construct函数对这块空间进行初始化，调用该函数时会传入这块空间的地址和用户传入的参数（需要经过完美转发）。
  3. 在allocator_traits::construct函数中会使用定位new表达式，显示调用构造函数对这块空间进行初始化，调用构造函数时会传入用户传入的参数（需要经过完美转发）。
  4. 将初始化好的新结点插入到对应的数据结构当中，比如list容器就是将新结点插入到底层的双链表中。

emplace系列接口的意义

  • 如果调用emplace系列接口时传入的是左值对象，那么首先需要先在此之前调用构造函数实例化出一个左值对象，最终在使用定位new表达式调用构造函数对空间进行初始化时，会匹配到拷贝构造函数。
  • 如果调用emplace系列接口时传入的是右值对象，那么就需要在此之前调用构造函数实例化出一个右值对象，最终在使用定位new表达式调用构造函数对空间进行初始化时，就会匹配到移动构造函数。
  • 如果调用emplace系列接口时传入的是参数包，那就可以直接调用函数进行插入，并且最终在使用定位new表达式调用构造函数对空间进行初始化时，匹配到的是构造函数。

总结一下：

  • 传入左值对象，需要调用构造函数+拷贝构造函数。
  • 传入右值对象，需要调用构造函数+移动构造函数。
  • 传入参数包，只需要调用构造函数。

当然，这里的前提是容器中存储的元素所对应的类，是一个需要深拷贝的类，并且该类实现了移动构造函数。否则调用emplace系列接口时，传入左值对象和传入右值对象的效果都是一样的，都需要调用一次构造函数和一次拷贝构造函数。

实际emplace系列接口的一部分功能和原有各个容器插入接口是重叠的，因为容器原有的push_back、push_front和insert函数也提供了右值引用版本的接口，如果调用这些接口时如果传入的是右值对象，那么最终也是会调用对应的移动构造函数进行资源的移动的。

emplace接口的意义：

  • emplace系列接口最大的特点就是支持传入参数包，用这些参数包直接构造出对象，这样就能减少一次拷贝，这就是为什么有人说emplace系列接口更高效的原因。
  • emplace系列接口真正高效的情况是传入参数包的时候，直接通过参数包构造出对象，避免了中途的一次拷贝。

验证

如果要验证我们上述对emplace系列接口的说法，需要借助一个深拷贝的类，下面模拟实现了一个简化版的string类，类当中只编写了我们需要用到的成员函数。

namespace zpl
{class string{public://构造函数string(const char* str = ""){cout << "string(const char* str) -- 构造函数" << endl;_size = strlen(str); //初始时，字符串大小设置为字符串长度_capacity = _size; //初始时，字符串容量设置为字符串长度_str = new char[_capacity + 1]; //为存储字符串开辟空间（多开一个用于存放'\0'）strcpy(_str, str); //将C字符串拷贝到已开好的空间}//交换两个对象的数据void swap(string& s){//调用库里的swap::swap(_str, s._str); //交换两个对象的C字符串::swap(_size, s._size); //交换两个对象的大小::swap(_capacity, s._capacity); //交换两个对象的容量}//拷贝构造函数（现代写法）string(const string& s):_str(nullptr), _size(0), _capacity(0){cout << "string(const string& s) -- 拷贝构造" << endl;string tmp(s._str); //调用构造函数，构造出一个C字符串为s._str的对象swap(tmp); //交换这两个对象}//移动构造string(string&& s):_str(nullptr), _size(0), _capacity(0){cout << "string(string&& s) -- 移动构造" << endl;swap(s);}//拷贝赋值函数（现代写法）string& operator=(const string& s){cout << "string& operator=(const string& s) -- 深拷贝" << endl;string tmp(s); //用s拷贝构造出对象tmpswap(tmp); //交换这两个对象return *this; //返回左值（支持连续赋值）}//移动赋值string& operator=(string&& s){cout << "string& operator=(string&& s) -- 移动赋值" << endl;swap(s);return *this;}//析构函数~string(){//delete[] _str;  //释放_str指向的空间_str = nullptr; //及时置空，防止非法访问_size = 0;      //大小置0_capacity = 0;  //容量置0}private:char* _str;size_t _size;size_t _capacity;};
}

由于我们在string的构造函数、拷贝构造函数和移动构造函数当中均打印了一条提示语句，因此我们可以通过控制台输出来判断这些函数是否被调用。

下面我们用一个容器来存储模拟实现的string，并以不同的传参形式调用emplace系列函数。比如：

int main()
{list<pair<int, cl::string>> mylist;pair<int, cl::string> kv(1, "one");mylist.emplace_back(kv);                              //传左值cout << endl;mylist.emplace_back(pair<int, cl::string>(2, "two")); //传右值cout << endl;mylist.emplace_back(3, "three");                      //传参数包return 0;
}

运行结果如下：
在这里插入图片描述
说明一下：

  • 模拟实现string的拷贝构造函数时复用了构造函数，因此在调用string拷贝构造的后面会紧跟着调用一次构造函数。
  • 为了更好的体现出参数包的概念，因此这里list容器中存储的元素类型是pair，我们是通过观察string对象的处理过程来判断pair的处理过程的。

这里也可以以不同的传参方式调用push_back函数，顺便验证一下容器原有的插入函数的执行逻辑。比如：

int main()
{list<pair<int, cl::string>> mylist;pair<int, cl::string> kv(1, "one");mylist.push_back(kv);                              //传左值cout << endl;mylist.push_back(pair<int, cl::string>(2, "two")); //传右值cout << endl;mylist.push_back({ 3, "three" });                  //列表初始化return 0;
}

运行结果如下：
在这里插入图片描述

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

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

相关文章

VM虚拟机使用的镜像文件下载

VM虚拟机使用的镜像文件下载

文章目录 Windows系统进入微软官网下载工具以Windows10为例下载镜像文件 Windows系统 进入微软官网下载工具 微软中国官网&#xff1a;https://www.microsoft.com/zh-cn/ 以Windows10为例下载镜像文件 选择下载的路径 开始下载 安装windows10操作系统出现Time out问题及解决办…
阅读更多...
【已解决】华为AR100-S路由器 恢复出厂后，找不到5G wifi的设置

【已解决】华为AR100-S路由器 恢复出厂后，找不到5G wifi的设置

前两帖讨论了华为AR100-S路由器&#xff1a; 一是用电脑浏览器访问web管理界面报错的解决&#xff0c;详情点这里&#xff01; https://blog.csdn.net/weixin_62598385/article/details/142215136 再就是如何回复出厂&#xff0c;也即如何复位&#xff0c; 详情点这里&#xff…
阅读更多...
简明linux系统编程--互斥锁--TCP--UDP初识

简明linux系统编程--互斥锁--TCP--UDP初识

目录 1.互斥锁 2.信号 2.1介绍 2.2信号的内核机制 3.linux网络编程概述 3.1一览七层协议 3.2一览数据传输过程 3.3四层网络模型 3.4服务端和客户端的数据交互 4.TCP服务端编程 5.TCP客户端编程 6.UDP服务端编程 7.UDP客户端编程 1.互斥锁 互斥锁也是和信号量一样&a…
阅读更多...
自动化测试常用函数

自动化测试常用函数

目录 一、元素的定位 1、cssSelector 2、xpath &#xff08;1&#xff09;xpath 语法 1、获取HTML页面所有的节点 2、获取HTML页面指定的节点 3、获取一个节点中的直接子节点 4、获取一个节点的父节点 5、实现节点属性的匹配 6、使用指定索引的方式获取对应的节点内容…
阅读更多...
鸿蒙OpenHarmony【轻量系统内核通信机制（消息队列）】子系统开发

鸿蒙OpenHarmony【轻量系统内核通信机制（消息队列）】子系统开发

消息队列 基本概念 消息队列又称队列&#xff0c;是一种任务间通信的机制。消息队列接收来自任务或中断的不固定长度消息&#xff0c;并根据不同的接口确定传递的消息是否存放在队列空间中。 任务能够从队列里面读取消息&#xff0c;当队列中的消息为空时&#xff0c;挂起读…
阅读更多...
Linux--禁止root用户通过ssh直接登录

Linux--禁止root用户通过ssh直接登录

原文网址&#xff1a;Linux--禁止root用户通过ssh直接登录_IT利刃出鞘的博客-CSDN博客 简介 本文介绍Linux服务器怎样禁止root用户通过ssh直接登录。 为什么要禁止&#xff1f; 因为root用户是每个Linux系统都有的&#xff0c;黑客可以使用root用户名尝试不同的密码来暴力破…
阅读更多...
ClickHouse 与 Quickwit 集成实现高效查询

ClickHouse 与 Quickwit 集成实现高效查询

1. 概述 在当今大数据分析领域&#xff0c;ClickHouse 作为一款高性能的列式数据库&#xff0c;以其出色的查询速度和对大规模数据的处理能力&#xff0c;广泛应用于在线分析处理 (OLAP) 场景。ClickHouse 的列式存储和并行计算能力使得它在处理结构化数据查询时极具优势&…
阅读更多...
【Elasticsearch】-spring boot 依赖包冲突问题

【Elasticsearch】-spring boot 依赖包冲突问题

<dependency><groupId>org.elasticsearch</groupId><artifactId>elasticsearch</artifactId><version>7.17.24</version></dependency> 在pom的配置中&#xff0c;只引入了elasticsearch-7.17.24 &#xff0c;但实际上会同时…
阅读更多...
seq2seq翻译实战-Pytorch复现

seq2seq翻译实战-Pytorch复现

&#x1f368; 本文为&#x1f517;365天深度学习训练营 中的学习记录博客&#x1f356; 原作者&#xff1a;K同学啊 code from __future__ import unicode_literals, print_function, division from io import open import unicodedata import string import re import rando…
阅读更多...
半导体器件制造5G智能工厂数字孪生物联平台，推进制造业数字化转型

半导体器件制造5G智能工厂数字孪生物联平台，推进制造业数字化转型

半导体器件制造行业作为高科技领域的核心驱动力&#xff0c;正积极探索和实践以5G智能工厂数字孪生平台为核心的新型制造模式。这一创新不仅极大地提升了生产效率与质量&#xff0c;更为制造业的未来发展绘制了一幅智能化、网络化的宏伟蓝图。 在半导体器件制造5G智能工厂中&a…
阅读更多...
RabbitMQ 高级特性——发送方确认

RabbitMQ 高级特性——发送方确认

文章目录 前言发送方确认confirm 确认模式return 退回模式 常见面试题 前言 前面我们学习了 RabbitMQ 中交换机、队列和消息的持久化&#xff0c;这样能够保证存储在 RabbitMQ Broker 中的交换机和队列中的消息实现持久化&#xff0c;就算 RabbitMQ 服务发生了重启或者是宕机&…
阅读更多...
中间件知识点-消息中间件（Rabbitmq）一

中间件知识点-消息中间件（Rabbitmq）一

消息中间件介绍 MQ的作用(优点)主要有以下三个方面&#xff1a; a.异步 b.解耦 c.削峰 MQ的作用(缺点)主要有以下三个方面&#xff1a; a.系统可用性降低 b.系统复杂度提高 c.存在消息一致性问题需要解决 备注&#xff1a; 引入MQ后系统的复杂度会大大提高。 以前服务之间可以…
阅读更多...
【软件基础知识】什么是 API，详细解读

【软件基础知识】什么是 API，详细解读

想象一下,你正在使用智能手机上的天气应用。你打开应用,瞬间就能看到实时天气、未来预报,甚至是空气质量指数。但你有没有想过,这些数据是如何神奇地出现在你的屏幕上的?答案就在三个字母中:API。 API,全称Application Programming Interface(应用程序编程接口),是现代软件世…
阅读更多...
计算机网络 --- 初识协议

计算机网络 --- 初识协议

序言 上一篇文章中 &#xff08;&#x1f449;点击查看&#xff09;&#xff0c;我们简单的了解了怎么寻找目标计算机&#xff0c;需要通过交换机&#xff0c;路由器等设备跨越多个网络来不断的转发我们需要传输的数据&#xff0c;直至到达目标计算机。  那我们设备之间数据是…
阅读更多...
重回极简：华为如何走向全面智能化？

重回极简：华为如何走向全面智能化？

“人类发现地球只是宇宙一员的时候&#xff0c;也是我们距离群星最遥远的时候。” 这个来自天文领域的喟叹&#xff0c;今天同样出现在行业与企业的智能化之路上。在这个时代坐标上&#xff0c;AI大模型技术极速成熟&#xff0c;AIGC和AI Agent等应用受到了各个行业的巨大期待。…
阅读更多...
昇腾大模型推理解决方案MindIE部署

昇腾大模型推理解决方案MindIE部署

MindIE大模型推理套件 MindIE&#xff08;Mind Inference Engine&#xff0c;昇腾推理引擎&#xff09;是华为公司针对AI全场景推出的整体解决方案&#xff0c;包含丰富的推理加速套件。通过开放各层次AI能力&#xff0c;支撑客户多样化的AI业务需求&#xff0c;使能百模千态&a…
阅读更多...
存储 NFS

存储 NFS

目录 1.存储的应用场景 2.存储分类 3.NFS服务组成 4.环境说明 ​编辑 5.服务端部署 6.NFS服务端的配置 7.NFS服务端本地进行测试 1.存储的应用场景 存储一般用于上传网站数据&#xff08;内容&#xff09;&#xff0c;一般用于在网站集群中。使用存储的话用户上传的…
阅读更多...
成型的程序

成型的程序

加一个提示信息 加上python 常用的包 整个程序打包完 250M 安装 960MB matplot numpy pandas scapy pysearial 常用的包 (pyvisa)… … 啥都有 Python 解释器组件构建 要比 lua 容易的多 &#xff08;C/Rust 的组件库)
阅读更多...
JavaSE--集合总览02：单列集合Collection的体系之一：List

JavaSE--集合总览02：单列集合Collection的体系之一：List

Collection体系的特点 分为 list 和set集合&#xff0c;这篇文章主要讲述List&#xff0c;下篇讲述Set。 简单认识单列集合collection集合的特点 : list集合的特点&#xff1a; 有序 可重复 有索引 set集合的特点&#xff1a;无序 不重复 无索引 其中LinkedHashSet有序 TreeS…
阅读更多...
微服务架构陷阱与挑战

微服务架构陷阱与挑战

微服务架构6大陷阱 现在微服务的基础设施还是越来越完善了&#xff0c;现在基础设施缺乏的问题逐渐被解决了。 拆分粒度太细&#xff0c;服务关系复杂 拆分降低了服务的内部复杂度&#xff0c;但是提升了系统的外部复杂度&#xff0c;服务越多&#xff0c;服务和服务之间的连接…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发