[C++11] 可变参数模板


文章目录

  • 基本语法及原理
    • 可变参数模板的基本语法
      • 参数包的两种类型
      • 可变参数模板的定义
    • `sizeof...` 运算符
    • 可变参数模板的实例化原理
    • 可变参数模板的意义
  • 包扩展
    • 包扩展的基本概念
    • 包扩展的实现原理
    • 编译器如何展开参数包
      • 包扩展的高级应用
  • `emplace` 系列接口
    • `emplace_back` 和 `emplace` 的作用和接口定义
    • `emplace` 系列接口的优势
    • `emplace_back` 的使用示例
    • `emplace_back` 内部实现分析
      • `ListNode` 节点类的实现
      • `emplace_back` 和 `insert` 的实现
      • 完美转发的作用
    • 编译器生成的代码

基本语法及原理

C++11引入了可变参数模板（Variadic Templates），使得我们可以定义参数数量可变的模板。可变参数模板广泛应用于泛型编程中，让开发者能够编写更加灵活和通用的代码。可变参数模板支持零或多个参数，极大地提升了模板的扩展性。

可变参数模板的基本语法

在C++11之前，为了实现不同数量的参数支持，必须针对不同数量的参数编写多个重载版本的函数或类模板。C++11提供了可变参数模板语法，允许开发者编写参数数量不定的模板函数和模板类。

参数包的两种类型

可变参数模板中的参数被称为参数包（Parameter Pack）。在C++11中，有两种参数包：

  1. 模板参数包：表示零或多个模板参数，使用 class... 或 typename... 关键字声明。
  2. 函数参数包：表示零或多个函数参数，使用类型名后跟 ... 表示。
template <class ...Args> void Func(Args... args) {}
template <class ...Args> void Func(Args&... args) {}
template <class ...Args> void Func(Args&&... args) {}

可变参数模板的定义

下面给出一个简单的可变参数模板的定义示例：

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

在上面的代码中：

  • Args... 是一个模板参数包，表示零个或多个类型参数。
  • args... 是一个函数参数包，对应零个或多个形参对象。

函数参数包可以用左值引用（Args&...）或右值引用（Args&&...）的形式表示，允许参数通过引用传递，从而符合C++的引用折叠规则。通过这些形式，我们可以灵活地处理传入的不同数量和类型的参数。

sizeof... 运算符

sizeof... 是一个操作符，用于计算参数包中参数的数量。它可以直接应用于模板参数包或函数参数包，返回参数包中包含的元素数量。以下是一个示例代码：

#include <iostream>
#include <string>
using namespace std;template <class ...Args>
void Print(Args&&... args) {cout << sizeof...(args) << endl;
}int main() {double x = 2.2;Print();                          // 包中有0个参数Print(1);                         // 包中有1个参数Print(1, string("xxxxx"));        // 包中有2个参数Print(1.1, string("xxxxx"), x);   // 包中有3个参数return 0;
}

该代码示例中，通过调用 sizeof...(args) 运算符，我们可以看到传入 Print 函数的参数数量。

可变参数模板的实例化原理

从编译的角度来看，可变参数模板的本质是在编译过程中，根据参数的数量和类型，实例化出多个函数版本。例如，上述示例中的 Print 函数调用，编译器会自动生成以下四个函数：

double x = 2.2;
Print();                          // 包中有0个参数
Print(1);                         // 包中有1个参数
Print(1, string("xxxxx"));        // 包中有2个参数
Print(1.1, string("xxxxx"), x);   // 包中有3个参数void Print();                                           // 0个参数
void Print(int&& arg1);                                 // 1个参数
void Print(int&& arg1, string&& arg2);                  // 2个参数
void Print(double&& arg1, string&& arg2, double& arg3); // 3个参数

这样，编译器会在调用处生成特定版本的函数。这种自动生成函数的方式，极大地简化了编写支持多个参数数量的函数的工作量。

可变参数模板的意义

在没有可变参数模板的情况下，我们需要通过写多个重载的函数模板来支持不同数量的参数：

void Print(); // 没有参数template <class T1>
void Print(T1&& arg1);template <class T1, class T2>
void Print(T1&& arg1, T2&& arg2);template <class T1, class T2, class T3>
void Print(T1&& arg1, T2&& arg2, T3&& arg3);

随着参数数量的增加，这种做法不仅繁琐，代码的可维护性也很差。通过可变参数模板，编译器可以自动生成相应数量和类型的函数版本，进一步解放了开发者的精力，使泛型编程更加灵活。

包扩展

在C++11中，可变参数模板不仅可以处理可变数量的参数，还支持对参数包进行“扩展”操作。包扩展允许我们分解参数包中的各个元素，并为每个元素应用某种模式，从而对其进行逐个处理。包扩展为模板元编程带来了极大的灵活性，使得我们可以编写简洁、高效的代码来处理不定数量的参数。

本文将深入探讨包扩展的概念、使用方法和实现原理。

包扩展的基本概念

对于一个参数包，我们可以：

  1. 计算参数包的元素数量（使用 sizeof... 操作符）。
  2. 进行包扩展，将参数包的元素逐个展开，并应用指定的模式。

在包扩展中，我们通过在模式的右边放置一个省略号（...）来触发扩展操作。扩展操作会将参数包逐个展开并应用模式，生成一个参数列表。例如，Args... args 表示参数包 Args... 被逐个展开为一个个单独的参数，供函数逐个处理。

包扩展的实现原理

包扩展的实现依赖于编译时递归调用和模式匹配。以下代码示例展示了如何通过包扩展实现对参数包中每个元素的打印：

#include <iostream>
#include <string>
using namespace std;// 递归终止条件：没有参数时停止递归
void ShowList() {cout << endl;
}// 递归展开参数包
template <class T, class ...Args>
void ShowList(T x, Args... args) {cout << x << " ";     // 打印当前参数ShowList(args...);     // 递归调用，展开剩余参数
}// 主调用接口，将参数包传给ShowList处理
template <class ...Args>
void Print(Args... args) {ShowList(args...);
}int main() {Print();                              // 输出：空行Print(1);                             // 输出：1Print(1, string("xxxxx"));            // 输出：1 xxxxxPrint(1, string("xxxxx"), 2.2);       // 输出：1 xxxxx 2.2return 0;
}

在上述代码中：

  1. 递归终止条件：void ShowList() 函数定义为空函数，当参数包为空时调用它，从而终止递归。
  2. 递归展开参数包：ShowList(T x, Args... args) 接受第一个参数 x，打印它，然后递归调用 ShowList(args...) 继续处理剩余的参数。

通过递归展开，Print 函数会依次打印每个参数，实现了包扩展。

编译器如何展开参数包

编译器在遇到包扩展时，会将参数包逐个展开为独立的参数并生成相应的函数调用。例如，以下代码调用 Print(1, string("xxxxx"), 2.2); 会展开为：

void ShowList(int x, string y, double z) {cout << x << " ";ShowList(y, z);
}

依次展开后，每次递归调用的 ShowList 函数都会处理一个参数，直到最后一个参数被处理完。

包扩展的高级应用

C++11 支持更复杂的包扩展，可以直接将参数包依次展开，并作为实参传递给另一个函数。例如，假设我们有一个 GetArg 函数，用于处理单个参数，并将其返回。我们可以使用包扩展，将参数包的每个元素都传递给 GetArg 处理，并将结果传给另一个函数 Arguments。

以下代码展示了这种高级的包扩展应用：

#include <iostream>
#include <string>
using namespace std;template <class T>
const T& GetArg(const T& x) {cout << x << " ";return x;
}template <class ...Args>
void Arguments(Args... args) {// 空函数，不做实际操作，仅用于接受展开后的参数
}template <class ...Args>
void Print(Args... args) {// 使用包扩展，将每个参数传递给GetArg处理，结果传给ArgumentsArguments(GetArg(args)...);// Arguments(GetArg(x), GetArg(y), GetArg(z));
}int main() {Print(1, string("xxxxx"), 2.2);    // 输出：1 xxxxx 2.2return 0;
}

在这段代码中：

  1. GetArg 是一个函数模板，用于打印并返回每个参数。
  2. 在 Print 中，GetArg(args)... 会将参数包 args... 依次传递给 GetArg 函数，并将 GetArg 的返回值传递给 Arguments，相当于利用Arguments这个空函数然后使用实际要将参数包各个参数传递给的函数GetArg()，然后实际上编译时的GetArg(args)...会变为：_**<font style="color:rgb(160,161,167);">Arguments(GetArg(x), GetArg(y), GetArg(z));</font>**_。
  3. 编译器会在编译时生成以下代码来完成包扩展：
void Print(int x, string y, double z) {Arguments(GetArg(x), GetArg(y), GetArg(z));
}

emplace 系列接口

C++11 为 STL 容器引入了 emplace 系列接口，例如 emplace_back 和 emplace，这些接口大幅提升了插入效率，尤其是在避免不必要的临时对象创建和拷贝构造方面。相比传统的 push_back 和 insert，emplace 系列允许在容器的内存空间上直接构造对象，减少了资源消耗。

emplace_back 和 emplace 的作用和接口定义

emplace_back 和 emplace 的作用是直接在容器空间中构造对象，避免了拷贝或移动构造。它们接受一组参数，通过可变参数模板实现：

template <class... Args>
void emplace_back(Args&&... args);template <class... Args>
iterator emplace(const_iterator position, Args&&... args);
  • emplace_back 接口将对象插入到容器末尾。
  • emplace 接口允许在容器的指定位置插入对象。

这两个接口都使用了可变参数模板 Args&&... args，可以接受任意数量的构造参数，使得在某些情况下比 push_back 和 insert 更高效。

emplace 系列接口的优势

emplace 系列的优势在于它可以避免创建临时对象。举个例子，假设我们有一个类型 T 和一个容器 container<T>，通过 emplace 接口，我们可以直接将构造 T 所需的参数传递给容器，直接在容器内存中构造 T 对象。这样减少了对象拷贝的需求，尤其在构造复杂对象时效率更高。

emplace_back 的使用示例

以下示例代码展示了 emplace_back 的不同用法：

#include <list>
#include <string>
#include <iostream>using namespace std;int main() {list<string> lt;// 传递左值，类似于 push_back，会调用拷贝构造string s1("111111111111");lt.emplace_back(s1);// 传递右值，类似于 push_back，会调用移动构造lt.emplace_back(move(s1));// 直接传递构造 string 的参数，emplace_back 在容器空间直接构造对象lt.emplace_back("111111111111");list<pair<string, int>> lt1;// 构造 pair 并拷贝/移动到 list 节点pair<string, int> kv("苹果", 1);lt1.emplace_back(kv);  // 拷贝lt1.emplace_back(move(kv)); // 移动// 直接传递构造 pair 的参数，在容器空间直接构造 pair 对象// 将参数包直接向下传，一直传到pair的构造，然后在对象的位置直接构造lt1.emplace_back("苹果", 1);return 0;
}

在上面的代码中，我们演示了 emplace_back 的三种使用方式：

  1. 传入左值参数（s1），进行拷贝构造。
  2. 传入右值参数（move(s1)），进行移动构造。
  3. 直接传递构造 string 和 pair 的参数，在容器内存中直接构造对象。

emplace_back 内部实现分析

为了理解 emplace 系列接口的实现，我们在给定代码中模拟了 list 容器的 emplace_back 和 insert 方法的实现。这些方法使用了可变参数模板和完美转发，确保参数类型的精确传递。

ListNode 节点类的实现

在ListNode中，通过模板构造函数实现直接构造数据类型 T 的对象，避免了额外的拷贝：

template <class T>
struct ListNode {ListNode<T>* _next;ListNode<T>* _prev;T _data;// 移动构造ListNode(T&& data): _next(nullptr), _prev(nullptr), _data(move(data)) {}// 可变参数模板构造函数template <class... Args>ListNode(Args&&... args): _next(nullptr), _prev(nullptr), _data(std::forward<Args>(args)...) {}
};

在这里，我们定义了 ListNode 的两种构造方式：

  1. 移动构造函数，用于右值参数。
  2. 可变参数模板构造函数，通过 std::forward<Args>(args)... 完美转发参数，实现对象的直接构造。

emplace_back 和 insert 的实现

emplace_back 是通过调用 insert 来实现的，而 insert 则会根据传递的参数类型直接在节点位置构造对象 T。

template <class T>
class list {typedef ListNode<T> Node;public:template <class... Args>void emplace_back(Args&&... args) {insert(end(), std::forward<Args>(args)...);}template <class... Args>iterator insert(iterator pos, Args&&... args) {Node* cur = pos._node;Node* newnode = new Node(std::forward<Args>(args)...); // 直接构造新节点Node* prev = cur->_prev;// 插入节点到链表prev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode);}private:Node* _head;
};
  • emplace_back 将参数包传递给 insert 方法。
  • insert 接受位置迭代器 pos 和一组可变参数，并通过 std::forward<Args>(args)... 将参数完美转发给 Node 构造函数。
  • insert 方法直接在链表节点位置构造对象，避免了不必要的拷贝操作。

完美转发的作用

传递参数包过程中，如果是<font style="color:rgb(31,35,41);"> Args&&... args </font>的参数包，要⽤完美转发参数包，⽅式如下<font style="color:rgb(31,35,41);">std::forward<Args>(args)... </font>，否则编译时包扩展后右值引⽤变量表达式就变成了左值。

在 emplace_back 的实现中，我们使用了 std::forward<Args>(args)...。完美转发确保参数类型保持不变（左值或右值），而不受函数调用的影响。如果不使用 std::forward，右值引用参数在传递过程中会被转换为左值引用，从而无法实现高效的移动语义。

编译器生成的代码

在实际编译过程中，编译器会根据传入的参数类型为 emplace_back 和 insert 生成适当的重载版本。例如，对于以下代码：

lt.emplace_back("111111111111");

编译器会自动生成以下版本的 emplace_back 函数：

void emplace_back(const char* s) 
{insert(end(), std::forward<const char*>(s));
}

每当传入不同参数组合，编译器会生成相应的重载函数，以实现高效的对象构造。

模拟实现的整体List.h:

// List.h
namespace bit
{template<class T>struct ListNode{ListNode<T>* _next;ListNode<T>* _prev;T _data;ListNode(T&& data):_next(nullptr), _prev(nullptr), _data(move(data)){}template <class... Args>ListNode(Args&&... args): _next(nullptr), _prev(nullptr), _data(std::forward<Args>(args)...){}};template<class T, class Ref, class Ptr>struct ListIterator{typedef ListNode<T> Node;typedef ListIterator<T, Ref, Ptr> Self;Node* _node;ListIterator(Node* node):_node(node){}// ++it;Self& operator++(){_node = _node->_next;return *this;}Self& operator--(){_node = _node->_prev;return *this;}Ref operator*(){return _node->_data;}bool operator!=(const Self& it){return _node != it._node;}};template<class T>class list{typedef ListNode<T> Node;public:typedef ListIterator<T, T&, T*> iterator;typedef ListIterator<T, const T&, const T*> const_iterator;iterator begin(){return iterator(_head->_next);}iterator end(){return iterator(_head);}void empty_init(){_head = new Node();_head->_next = _head;_head->_prev = _head;}list(){empty_init();}void push_back(const T& x){insert(end(), x);}void push_back(T&& x){insert(end(), move(x));}iterator insert(iterator pos, const T& x){Node* cur = pos._node;Node* newnode = new Node(x);Node* prev = cur->_prev;// prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode);}iterator insert(iterator pos, T&& x){Node* cur = pos._node;Node* newnode = new Node(move(x));Node* prev = cur->_prev;// prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode);}template <class... Args>void emplace_back(Args&&... args){insert(end(), std::forward<Args>(args)...);}// 原理：本质编译器根据可变参数模板⽣成对应参数的函数/*void emplace_back(string& s){insert(end(), std::forward<string>(s));}void emplace_back(string&& s){insert(end(), std::forward<string>(s));}void emplace_back(const char* s){insert(end(), std::forward<const char*>(s));}*/template <class... Args>iterator insert(iterator pos, Args&&... args){Node* cur = pos._node;Node* newnode = new Node(std::forward<Args>(args)...);Node* prev = cur->_prev;// prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode);}private:Node* _head;};
}

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

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

使用Ubuntu快速部署MinIO对象存储

使用Ubuntu快速部署MinIO对象存储

想拥有自己的私有云存储&#xff0c;安全可靠又高效&#xff1f;MinIO是你的理想选择&#xff01;这篇文章将手把手教你如何在Ubuntu 22.04服务器上部署MinIO&#xff0c;并使用Nginx反向代理和Let’s Encrypt证书进行安全加固。 即使你是新手&#xff0c;也能轻松完成&#xf…
阅读更多...
贝尔不等式，路径积分与AB（Aharonov-Bohm）效应

贝尔不等式，路径积分与AB（Aharonov-Bohm）效应

贝尔不等式、路径积分与Aharonov-Bohm&#xff08;AB&#xff09;效应 这些概念分别源于量子力学不同的理论分支和思想实验&#xff0c;但它们都揭示了量子力学的奇异性质&#xff0c;包括非局域性、相位效应和波粒二象性。以下详细解析每一概念&#xff0c;并探讨其相互联系。…
阅读更多...
用友U8接口-isHasCounterSignPiid错误

用友U8接口-isHasCounterSignPiid错误

错误消息 调用U813的审批流方法报错&#xff0c;找不到方法:“Boolean UFIDA.U8.Audit.BusinessService.ManualAudit.isHasCounterSignPiid System.Web.Services.Protocols.SoapException:服务器无法处理请求。 ---> System.MissingMethodException: 找不到方法:“Boolean…
阅读更多...
QJson-趟过的各种坑(先坑后用法)

QJson-趟过的各种坑(先坑后用法)

QJson-趟过的各种坑【先坑后用法】 Chapter1 QJson-趟过的各种坑【先坑后用法】一、不能处理大数据量&#xff0c;如果你的数据量有百兆左右(特别是有的小伙伴还喜欢json格式化输出的)&#xff0c;不要用Qjson&#xff0c;否则会报错 DocumentTooLarge二、json格式化输出1.构建…
阅读更多...
flink实战-- flink任务的火焰图如何使用

flink实战-- flink任务的火焰图如何使用

火焰图 Flame Graphs 是一种有效的可视化工具，可以帮助我们排查如下问题： 目前哪些方法正在消耗 CPU 资源？一个方法的消耗与其他方法相比如何？哪一系列的堆栈调用导致了特定方法的执行?y 轴表示调用栈，每一层都是一个函数。调用栈越深，火焰就越高，顶部就是正在执行的…
阅读更多...
.Net Core 6.0 WebApi在Centos中部署

.Net Core 6.0 WebApi在Centos中部署

查看已经开发的端口的列表 firewall-cmd --zonepublic --list-ports .net core sdk密匙 sudo rpm -Uvh https://packages.microsoft.com/config/centos/7/packages-microsoft-prod.rpm sudo yum update .net core sdk安装 sudo yum install -y dotnet-sdk-6.0 sudo dnf in…
阅读更多...
Java基于SpringBoot+Vue的农产品电商平台

Java基于SpringBoot+Vue的农产品电商平台

大家好&#xff0c;我是Java徐师兄&#xff0c;今天为大家带来的是Java基于SpringBoot 的农产品电商平台。该系统采用 Java 语言 开发&#xff0c;MySql 作为数据库&#xff0c;系统功能完善 &#xff0c;实用性强 &#xff0c;可供大学生实战项目参考使用。 博主介绍&#xff…
阅读更多...
一文读懂系列：结合抓包分析，详解SSH协议通信原理

一文读懂系列：结合抓包分析，详解SSH协议通信原理

SSH协议通过建立加密通道来提供安全的远程访问、文件传输和执行远程命令等操作。接下来我们就通过具体示例和抓包分析&#xff0c;让大家清楚地了解SSH协议的神秘面纱&#xff01;如有更多疑问&#xff0c;欢迎讨论区留言讨论~ 1. SSH简介 SSH&#xff08;Secure Shell&#x…
阅读更多...
数据冒险-ld和add（又称load-use冒险）

数据冒险-ld和add（又称load-use冒险）

第一张图没有使用前递&#xff0c;第二张图使用前递&#xff0c;chatgpt分析第二张图 这张图展示了一个流水线的执行过程&#xff0c;其中存在读后写&#xff08;RAW&#xff09;数据冒险。我们可以通过**前递&#xff08;Forwarding&#xff09;**技术来解决这个数据冒险&…
阅读更多...
Java 的 Scanner 类：控制台输入与文件扫描

Java 的 Scanner 类：控制台输入与文件扫描

Java 的 Scanner 类是一个非常方便的工具类&#xff0c;主要用于从控制台或文件中扫描输入数据。虽然它也可以用于扫描文件内容&#xff0c;但我们通常更喜欢它用于控制台输入&#xff0c;因为扫描文件可以通过文件流来完成。接下来&#xff0c;我们将通过几个简单的示例来讲解…
阅读更多...
安卓市场如何做APP的分发、推广？

安卓市场如何做APP的分发、推广？

今天主要跟大家分享一些分发、推广这块操作的内容以及对安卓用户的一些理解。 分发的日常生活&#xff1a;“某渠道怎样怎样&#xff0c;应用宝是不是要加点预算&#xff0c;OPPO是不是要加点预算&#xff0c;你的成本又高了&#xff0c;华为又掉注册&#xff0c;应用宝又掉注册…
阅读更多...
基于JavaWeb的图书售卖网站（源码+部署+LW）

基于JavaWeb的图书售卖网站（源码+部署+LW）

项目描述 临近学期结束&#xff0c;还是毕业设计&#xff0c;你还在做java程序网络编程&#xff0c;期末作业&#xff0c;老师的作业要求觉得大了吗?不知道毕业设计该怎么办?网页功能的数量是否太多?没有合适的类型或系统?等等。今天给大家介绍一篇基于JavaWeb的图书售卖网…
阅读更多...
高级 ＜HarmonyOS主题课＞构建华为支付服务的课后习题

高级 ＜HarmonyOS主题课＞构建华为支付服务的课后习题

五色令人目盲&#xff1b; 五音令人耳聋&#xff1b; 五味令人口爽&#xff1b; 驰骋畋猎&#xff0c;令人心发狂&#xff1b; 难得之货&#xff0c;令人行妨&#xff1b; 是以圣人为腹不为目&#xff0c;故去彼取此。 本篇内容主要来自&#xff1a;<HarmonyOS主题课>构建…
阅读更多...
python全栈开发《63.判断两个集合中是否有相同的元素》

python全栈开发《63.判断两个集合中是否有相同的元素》

目录 1.isdisjoint的功能2.isdisjoint的用法3.代码 1.isdisjoint的功能 判断两个集合是否包含相同的元素。如果没有&#xff0c;返回True&#xff1b;如果有&#xff0c;返回False。 2.isdisjoint的用法 a_set {name,xiaomu,xiaoming} b_set {xiaoming,xiaogang,xiaohong} re…
阅读更多...
员工管理系统（python）

员工管理系统（python）

利用python的自定义函数以及循环函数写一个小的员工管理系统&#xff0c;以下是详细代码&#xff1a; # 定义一个空的员工列表&#xff0c;用于存储员工信息 list_ems []# 添加员工的函数 def add():# 提示用户输入员工的各项信息employee_id input("请输入员工的工号&…
阅读更多...
做AI大模型应用层产品研发，基本绕不开这几个大模型API

做AI大模型应用层产品研发，基本绕不开这几个大模型API

国内有不少独立模型厂商提供 API 可供调用&#xff0c;几乎都会成为技术选择的可选项&#xff1a; Moonshot AI&#xff1a; API 特点&#xff1a;其 API 与 OpenAI 兼容&#xff0c;方便开发者平滑迁移&#xff0c;开发者无需对代码做除基本参数外的“额外”修改&#xff0c;…
阅读更多...
MySQL数据库专栏（五）连接MySQL数据库C API篇

MySQL数据库专栏（五）连接MySQL数据库C API篇

摘要 本篇文章主要介绍通过C语言API接口链接MySQL数据库&#xff0c;各接口功能及使用方式&#xff0c;辅助类的封装及调用实例&#xff0c;可以直接移植到项目里面使用。 目录 1、环境配置 1.1、添加头文件 1.2、添加库目录 2、接口介绍 2.1、MySql初始化及数据清理 2.1.…
阅读更多...
Ubuntu系统被木马程序攻击，运行莫名进程杀掉又自动重启解决办法

Ubuntu系统被木马程序攻击，运行莫名进程杀掉又自动重启解决办法

问题&#xff1a;Ubuntu系统被攻击了&#xff0c;有莫名进程运行杀掉又自动重启。 原因&#xff1a;攻击原因估计是用户名和密码过于简单&#xff0c;ssh服务穿透时等被暴力破解了。 nvidia-smi&#xff1a;存在莫名的./java程序&#xff0c;kill掉也会重启其它木马进程&#…
阅读更多...
Java基于SpringBoot+Vue框架的宠物寄养系统（V2.0），附源码，文档

Java基于SpringBoot+Vue框架的宠物寄养系统（V2.0），附源码，文档

博主介绍&#xff1a;✌程序员徐师兄、7年大厂程序员经历。全网粉丝12w、csdn博客专家、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精彩专栏推荐订阅&#x1f447;…
阅读更多...
【MySQL】函数

【MySQL】函数

3.函数 MySQL中的函数主要分为以下四类&#xff1a; 字符串函数、数值函数、日期函数、流程函数。 3.1 字符串函数 演示如下&#xff1a; A. concat : 字符串拼接 select concat(Hello , MySQL);B. lower : 全部转小写 select lower(Hello);C. upper : 全部转大写 select…
阅读更多...
最新文章

Copyright @ 2022~2023