C++11(3)

embedded/2024/9/19 14:25:10/ 标签: c++, java, 开发语言

目录

可变参数模版

获取参数包值的方式

1.递归方式展开参数包

2.使用数组+逗号表达式展开

emplace_back函数

lambda表达式

C++98中的例子

lambda表达式

语法

lambda表达式和函数比较

包装器

function包装器

bind绑定器


可变参数模版

C++11 的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板,相比C++98/03,类模版和函数模版中只能含 固定数量 的模版参数,可变模版参数无疑是一个巨大的改
进。然而由于可变模版参数比较抽象,使用起来需要一定的技巧,所以这块还是比较晦涩的。现
阶段呢,我们掌握一些基础的可变参数模板特性就够我们用了,所以这里我们点到为止,以后大
家如果有需要,再可以深入学习。
下面就是一个基本可变参数的函数模板:
// Args是一个模板参数包,args是一个函数形参参数包
// 声明一个参数包Args...args,这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

我们可以发现其实参数包就是将多个模版参数类型和参数都使用Args包装起来了,为了辨别与普通参数的区别,所以三个点是必要的;

上面的参数 args 前面有省略号,所以它就是一个可变模版参数,我们把带省略号的参数称为 参数
,它里面包含了 0 N N>=0 )个模版参数。我们无法直接获取参数包 args 中的每个参数的,
只能通过 展开参数包的方式来获取参数包中的每个参数 ,这是使用可变模版参数的一个主要特
点,也是最大的难点,即如何展开可变模版参数。由于语法 不支持使用args[i]这样方式 获取可变
参数,所以我们的用一些奇招来一一获取参数包的值。

获取参数包值的方式

1.递归方式展开参数包

#define _CRT_SECURE_NO_WARNINGS 1#include<iostream>
#include<vector>
#include<functional>
using namespace std;//结束递归函数
template<class T>
void ShowList(const T& value)//但最后只有一个参数时,调用该函数停止
{cout << value << endl;
} 
// Args是一个模板参数包,args是一个函数形参参数包
// 声明一个参数包Args...args,这个参数包中可以包含0到任意个模板参数。
template <class T, class ...Args>
void ShowList(T value, Args... args)
{cout << value << " ";ShowList(args...);         //递归下一次,参数包中会分理出一个参数value;
}int main()   
{//可以传任意多个参数ShowList(1, "564", 5.4); ShowList(1, 2, 5, 8, 4, 65, 6, 5);return 0;
}

参数包的优势就是参数不是固定的,可以随意的传递多个参数,递归是调用模版函数,每次都会从参数包中分出若干个参数使用;直到最后剩下的个数正好等于ShowList的使用参数个数(一个)时可传递参数时,就要手写一个停止的函数;

按照这样的方式,当然,也可以一次从参数包中分离出多个参数使用,但是最后要确保参数包中的参数要没有剩余;

#define _CRT_SECURE_NO_WARNINGS 1#include<iostream>
#include<vector>
#include<functional>
using namespace std;//结束递归函数
template<class T,class R>
void ShowList(T& val1,R& val2 )//但最后只有两个参数时(参数包没有剩余时),调用该函数停止 
{cout << val1 << " " << val2 << endl;      cout << "结束了" << endl; 
} 
// Args是一个模板参数包,args是一个函数形参参数包
// 声明一个参数包Args...args,这个参数包中可以包含0到任意个模板参数。
template <class T, class R,class ...Args>
void ShowList(T value1,R value2 ,Args... args)//可以一次分裂出多个参数使用,但是要确保最后参数包没有多余的参数
{cout << value1 << " "<<value2<<" ";ShowList(args...);         //递归下一次,参数包中会分理出两个参数value;
}int main()   
{//上面的函数依次使用了两个参数,所以实参必须是2的倍数ShowList(1, "564", 5.4,8); ShowList(1, 2, 5, 8, 4, 65, 6, 5);return 0;
}

运行结果:;除了这种方法之外,还可以使用数组结合逗号表达式来一次性使用所有的参数;

2.使用数组+逗号表达式展开

这种展开参数包的方式,不需要通过递归终止函数,是直接在 expand 函数体中展开的 , printarg
不是一个递归终止函数,只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式
实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。
expand 函数中的逗号表达式: (printarg(args), 0) 也是按照这个执行顺序,先执行
printarg(args),再得到逗号表达式的结果0 。同时还用到了 C++11 的另外一个特性 —— 初始化列
表, 通过初始化列表来初始化一个变长数组 , {(printarg(args), 0)...} 将会展开成 ((printarg(arg1),0),
(printarg(arg2),0), (printarg(arg3),0), etc... ) ,最终会创建一个元素值都为 0 的数组int arr[sizeof...
(Args)] 由于是逗号表达式,在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)
打印出参数,也就是说在构造int数组的过程中就将参数包展开了 ,这个数组的目的纯粹是为了在
数组构造的过程展开参数包;
template<class T >
void print(T value)    //每次调用函数都会分离出一个参数
{cout << value << " ";
}template<class ...Args>
void ShowList(Args... args)
{int arr[] = { (print(args),0)... };     //使用逗号表达式,间接的执行函数;return;
}int main()
{ShowList("456", 2, 45, 616 );return 0;}

emplace_back函数

STL 容器中的 empalce 相关接口函数:
http://www.cplusplus.com/reference/vector/vector/emplace_back/
http://www.cplusplus.com/reference/list/list/emplace_back/
template <class... Args>
void emplace_back (Args&&... args);
首先我们看到的 emplace 系列的接口,支持模板的可变参数,并且万能引用。那么相对 insert
emplace 系列接口的优势到底在哪里呢?
int main()
{std::list< std::pair<int, char> > mylist;  // emplace_back支持可变参数,拿到构建pair对象的参数后自己去创建对象// 那么在这里我们可以看到除了用法上,和push_back没什么太大的区别mylist.emplace_back(10, 'a');mylist.emplace_back(20, 'b');//可以直接传模版类型;mylist.emplace_back(make_pair(30, 'c'));//否则就需要传递list的变量mylist.push_back(make_pair(40, 'd'));mylist.push_back({ 50, 'e' });//列表初始化构造pairfor (auto e : mylist)cout << e.first << ":" << e.second << endl;return 0;
}

以上面的代码为例,如果我们尾插节点,通常是需要先构造pair类型的变量,然后再尾插;C++11出来后由于列表初始化的出现,使用{}可以自动调用构造函数初始化,极大地方便了我们;但是除此之外;可变参数包的使用,使得emplace_back可以直接传递pair的参数就可以自动按照顺序调用构造;类似与上面一次使用多个参数的情况;

注意:emplace_back与push_back都只能依次尾插一个节点;

lambda表达式

C++98中的例子

C++98 中,如果想要对一个数据集合中的元素进行排序,可以使用 std::sort 方法;
int main()
{int array[] = { 4,1,8,5,3,7,0,9,2,6 };// 默认按照小于比较,排出来结果是升序std::sort(array, array + sizeof(array) / sizeof(array[0]));// 如果需要降序,需要改变元素的比较规则std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());return 0;
}

其中需要注意的就是greater是个仿函数;

这里补充下仿函数的知识:
什么是仿函数?

仿函数实质上是一个重载了括号的模版类;通常适用于比较自定义类型的大小,按照某一特性进行排序的方法;
上述代码的仿函数可以这样实现;

template<class T>
class _greater//为了避免与std中的冲突
{
public:bool operator ()(T a, T b)     {return a > b;}
};
int main()
{int array[] = { 4,1,8,5,3,7,0,9,2,6 };// 默认按照小于比较,排出来结果是升序std::sort(array, array + sizeof(array) / sizeof(array[0]));// 如果需要降序,需要改变元素的比较规则std::sort(array, array + sizeof(array) / sizeof(array[0]), _greater<int>());for (auto& e : array)cout << e << " ";return 0;
}

为什么要用仿函数,仿函数和普通的比较函数有什么区别?

答:1.灵活性和扩展性

普通比较函数:
普通比较函数的灵活性相对较低。它们只能执行静态的比较操作,并且不能存储状态或其他信息
仿函数:
仿函数可以存储状态和其他成员变量,这使得它们在某些情况下比普通函数更强大。例如,你可以使用仿函数来维护计数器或其他状态信息:

class CompareWithCount {public:CompareWithCount() : count(0) {}bool operator()(int a, int b) {++count;return a < b;}int getCount() const { return count; }private:int count;};在这种情况下,你可以在排序操作后检查比较操作的次数:CompareWithCount comp;std::sort(arr, arr + size, comp);std::cout << "Number of comparisons: " <<comp.getCount() << std::endl;

2.性能和优化

普通比较函数:
普通比较函数通常会有较少的开销,因为它们没有对象的创建和销毁开销,也没有成员变量的存储。
仿函数:
仿函数可以在编译时内联,因此在某些情况下,它们可以比普通函数更高效,尤其是当仿函数的 operator() 被内联时。此外,仿函数的成员变量可以在执行时保持状态,这在某些复杂的操作中可能提供性能优势。

如果待排序元素为自定义类型,需要用户定义排序时的比较规则:
struct Goods
{string _name;  // 名字double _price; // 价格int _evaluate; // 评价Goods(const char* str, double price, int evaluate):_name(str), _price(price), _evaluate(evaluate){}
};
struct ComparePriceLess
{bool operator()(const Goods& gl, const Goods& gr){return gl._price < gr._price;
}
};
struct ComparePriceGreater
{bool operator()(const Goods& gl, const Goods& gr){return gl._price > gr._price;}
};
int main()
{vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 
3 }, { "菠萝", 1.5, 4 } };sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
}
随着 C++ 语法的发展, 人们开始觉得上面的写法太复杂了,每次为了实现一个 algorithm 算法,
都要重新去写一个类,如果每次比较的逻辑不一样,还要去实现多个类,特别是相同类的命名,
这些都给编程者带来了极大的不便 。因此,在 C++11 语法中出现了 Lambda 表达式;

lambda表达式

先展示下lambda表达式的使用;

int main()
{vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 
3 }, { "菠萝", 1.5, 4 } };sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._price < g2._price; });sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._price > g2._price; });sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._evaluate < g2._evaluate; });sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._evaluate > g2._evaluate; });
}
上述代码就是使用 C++11 中的 lambda 表达式来解决,可以看出 lambda 表达式实际是一个匿名函
数。

语法

ambda 表达式书写格式 [capture-list] (parameters) mutable -> return-type { statement
}
1. lambda 表达式各部分说明
[capture-list] : 捕捉列表 ,该列表总是出现在 lambda 函数的开始位置, 编译器根据 []
判断接下来的代码是否为 lambda 函数 捕捉列表能够捕捉上下文中的变量供 lambda
函数使用,是不可以省略的
(parameters) :参数列表。与 普通函数的参数列表一致 ,如果不需要参数传递,则可以
连同 () 一起省略
mutable :默认情况下, lambda 函数总是一个 const函数 mutable 可以取消其常量
性。使用该修饰符时, 参数列表不可省略 ( 即使参数为空 )。
->returntype :返回值类型 。用 追踪返回类型形式声明函数的返回值类型 没有返回
值时此部分可省略 返回值类型明确情况下,也可省略,由编译器对返回类型进行推
{statement} :函数体 。在该函数体内,除了可以使用其参数外,还可以使用所有捕获
到的变量。
注意:
lambda 函数定义中, 参数列表和返回值类型都是可选部分,而捕捉列表和函数体可以为
。因此 C++11 最简单的 lambda 函数为: []{...} ; lambda 函数不能做任何事情。
int main()
{// 最简单的lambda表达式, 该lambda表达式没有任何意义[] {};// 省略参数列表和返回值类型,返回值类型由编译器推导为intint a = 3, b = 4;[=] {return a + 3; };//[=]捕捉(=就是拷贝)所有之前出现的变量;可以在函数体使用;// 省略了返回值类型,无返回值类型auto fun1 = [&](int c) {b = a + c; };fun1(10);cout << a << " " << b << endl;   // 各部分都很完善的lambda函数auto fun2 = [=, &b](int c)->int {return b += a + c; };cout << fun2(10) << endl;// 复制捕捉xint x = 10;//需要使用mutable才能改变拷贝的x;auto add_x = [x](int a) mutable { x *= 2; return a + x; };cout << add_x(10) << endl;        return 0;
}
通过上述例子可以看出, lambda 表达式实际上可以理解为无名函数,该函数无法直接调
用,如果想要直接调用,可借助 auto将其赋值给一个变量;
捕获列表说明
捕捉列表描述了上下文中那些数据可以被 lambda 使用 ,以及 使用的方式传值还是传引用
[var] :表示值传递方式捕捉变量 var
[=] :表示值传递方式捕获所有父作用域中的变量 ( 包括 this)
[&var] :表示引用传递捕捉变量 var
[&] :表示引用传递捕捉所有父作用域中的变量 ( 包括 this)
[this] :表示值传递方式捕捉当前的 this 指针
注意:
a. 父作用域指包含 lambda 函数的语句块
b. 语法上捕捉列表可由多个捕捉项组成,并以逗号分割
比如: [=, &a, &b] :以引用传递的方式捕捉变量 a b ,值传递方式捕捉其他所有变量[&, a, this]; 值传递方式捕捉变量 a this ,引用方式捕捉其他变量
c. 捕捉列表不允许变量重复传递,否则就会导致编译错误
比如: [=, a] = 已经以值传递方式捕捉了所有变量,捕捉 a 重复
d. 在块作用域以外的 lambda 函数捕捉列表必须为空
e. 在块作用域中的 lambda 函数仅能捕捉父作用域中局部变量,捕捉任何非此作用域或者非局部变量会导致编译报错。
f. lambda 表达式之间不能相互赋值 ,即使看起来类型相同
void (*PF)();
int main()
{auto f1 = []{cout << "hello world" << endl; };auto f2 = []{cout << "hello world" << endl; };// 此处先不解释原因,等lambda表达式底层实现原理看完后,大家就清楚了//f1 = f2;   // 编译失败--->提示找不到operator=()// 允许使用一个lambda表达式拷贝构造一个新的副本auto f3(f2);f3();// 可以将lambda表达式赋值给相同类型的函数指针PF = f2;PF();return 0;
}

lambda表达式和函数比较

函数对象,又称为仿函数,即可以想函数一样使用的对象,就是在类中重载了 operator() 运算符的
类对象。
class Rate
{
public:Rate(double rate): _rate(rate){}double operator()(double money, int year){ return money * _rate * year;}
private:double _rate;
};
int main()
{
// 函数对象double rate = 0.49;Rate r1(rate);r1(10000, 2);
// lamberauto r2 = [=](double monty, int year)->double{return monty*rate*year; 
};r2(10000, 2);return 0;
}
从使用方式上来看,函数对象与 lambda 表达式完全一样。
函数对象将 rate 作为其成员变量,在定义对象时给出初始值即可, lambda 表达式通过捕获列表可
以直接将该变量捕获到。
实际在底层编译器对于 lambda 表达式的处理方式,完全就是按照函数对象的方式处理的,即:如
果定义了一个 lambda 表达式,编译器会自动生成一个类,在该类中重载了 operator()

包装器

function包装器

function 包装器 也叫作适配器。 C++ 中的 function 本质是一个类模板,也是一个包装器。那么我们来看看,我们为什么需要function 呢?
ret = func(x);
// 上面func可能是什么呢?那么func可能是函数名?函数指针?函数对象(仿函数对象)?也有可能
是lamber表达式对象?所以这些都是可调用的类型!如此丰富的类型,可能会导致模板的效率低下!
为什么呢?我们继续往下看
template<class F, class T>
T useF(F f, T x)
{static int count = 0;cout << "count:" << ++count << endl;cout << "count:" << &count << endl;return f(x);
}
double f(double i)
{return i / 2;
}
struct Functor
{double operator()(double d){return d / 3;}
};
int main()
{
// 函数名cout << useF(f, 11.11) << endl;// 函数对象cout << useF(Functor(), 11.11) << endl;// lamber表达式cout << useF([](double d)->double{ return d/4; }, 11.11) << endl;return 0;
}
通过上面的程序验证,我们会发现 useF 函数模板实例化了三份。
包装器可以很好的解决上面的问题
std::function在头文件<functional>
// 类模板原型如下
template <class T> function;     // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明:
Ret: 被调用函数的返回类型
Args…:被调用函数的形参
// 使用方法如下:以加法为例
#include <functional>
int f(int a, int b)
{return a + b;
}
struct Functor
{
public:int operator() (int a, int b){return a + b;}
};
class Plus
{
public:static int plusi(int a, int b)//静态函数{return a + b;}double plusd(double a, double b)//成员函数{return a + b;}
};
int main()
{// 函数名(函数指针)std::function<int(int, int)> func1 = f;cout << func1(1, 2) << endl;// 函数对象std::function<int(int, int)> func2 = Functor();cout << func2(1, 2) << endl;// lamber表达式std::function<int(int, int)> func3 = [](const int a, const int b) 
{return a + b; };cout << func3(1, 2) << endl;// 类的成员函数std::function<int(int, int)> func4 = &Plus::plusi;cout << func4(1, 2) << endl;std::function<double(Plus, double, double)> func5 = &Plus::plusd;//包装成员函数需要多一个参数Plus(隐含的this)cout << func5(Plus(), 1.1, 2.2) << endl;return 0;
}
有了包装器,如何解决模板的效率低下,实例化多份的问题呢?
#include <functional>
template<class F, class T>
T useF(F f, T x)
{static int count = 0;cout << "count:" << ++count << endl;cout << "count:" << &count << endl;return f(x);
}
double f(double i)
{return i / 2;
}
struct Functor
{double operator()(double d){return d / 3;}
};
int main()
{
// 函数名std::function<double(double)> func1 = f;cout << useF(func1, 11.11) << endl;// 函数对象std::function<double(double)> func2 = Functor();cout << useF(func2, 11.11) << endl;// lamber表达式std::function<double(double)> func3 = [](double d)->double{ return d /
4; };cout << useF(func3, 11.11) << endl;return 0;
}
包装器的其他一些场景: https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/submissions/

bind绑定器

std::bind 函数定义在头文件中, 是一个函数模板,它就像一个函数包装器 ( 适配器 ) 接受一个可
调用对象( callable object ),生成一个新的可调用对象来 适应 原对象的参数列表 。一般而
言,我们用它可以把一个原本接收 N 个参数的函数 fn ,通过绑定一些参数,返回一个接收 M 个( M
可以大于 N ,但这么做没什么意义)参数的新函数。同时,使用 std::bind 函数还可以实现参数顺
序调整等操作。
// 原型如下:
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2) 
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
可以将 bind 函数看作是一个通用的函数适配器,它接受一个可调用对象,生成一个新的可调用对
象来 适应 原对象的参数列表。
调用 bind 的一般形式: auto newCallable = bind(callable,arg_list);
其中, newCallable 本身是一个可调用对象, arg_list 是一个逗号分隔的参数列表,对应给定的
callable 的参数。 当我们调用 newCallable 时, newCallable 会调用 callable, 并传给它 arg_list
的参数
arg_list 中的参数可能包含形如 _n 的名字,其中 n 是一个整数,这些参数是 占位符 ,表示newCallable的参数,它们占据了传递给 newCallable 的参数的 位置 。数值 n 表示生成的可调用对
象中参数的位置: _1为newCallable的第一个实参,_2为第二个实参, 以此类推;
// 使用举例
#include <functional>int Plus(int a, int b)
{return a + b;
}class Sub
{
public:int sub(int a, int b){return a - b;}
};int main()
{//表示绑定函数plus 参数分别由调用 func1 的第一,二个参数指定std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1, 
placeholders::_2);//auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);//func2的类型为 function<void(int, int, int)> 与func1类型一样//表示绑定函数 plus 的第一,二为: 1, 2auto  func2 = std::bind(Plus, 1, 2);   cout << func1(1, 2) << endl;cout << func2() << endl;Sub s;// 绑定成员函数std::function<int(int, int)> func3 = std::bind(&Sub::sub, s, 
placeholders::_1, placeholders::_2);// 参数调换顺序
std::function<int(int, int)> func4 = std::bind(&Sub::sub, s, 
placeholders::_2, placeholders::_1);cout << func3(1, 2) << endl; //1-2cout << func4(1, 2) << endl;//2-1return 0;
}

注意:为了方便使用,可以以using placeholders::_1的形式使用;


http://www.ppmy.cn/embedded/113041.html

相关文章

ElK 8 收集 Nginx 日志

1. 说明 elk 版本&#xff1a;8.15.0 2. 启个 nginx 有 nginx 可以直接使用。我这里是在之前环境下 docker-compose.yml 中启动了个 nginx&#xff1a; nginx:restart: alwaysimage: nginx:1.26.1ports:- "80:80"- "443:443"volumes:#- ./nginx/html:/…

Nuxt Kit 中的页面和路由管理

title: Nuxt Kit 中的页面和路由管理 date: 2024/9/17 updated: 2024/9/17 author: cmdragon excerpt: 摘要:本文介绍了Nuxt Kit中页面和路由管理的高级功能,包括extendPages自定义页面路由、extendRouteRules定义复杂路由逻辑及addRouteMiddleware注册路由中间件。通过这…

[苍穹外卖]-12Apache POI入门与实战

工作台 需求分析: 工作台是系统运营的数据看板, 并提供快捷操作入口, 可以有效提高商家的工作效率 营业额: 已完成订单的总金额有效订单: 已经完成订单的数量订单完成率: 有效订单数/总订单数*100%平均客单价: 营业额/有效订单数新增用户: 新增的用户数量 接口设计: 一个接口返…

计算机毕业设计 二手闲置交易系统的设计与实现 Java实战项目 附源码+文档+视频讲解

博主介绍&#xff1a;✌从事软件开发10年之余&#xff0c;专注于Java技术领域、Python人工智能及数据挖掘、小程序项目开发和Android项目开发等。CSDN、掘金、华为云、InfoQ、阿里云等平台优质作者✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精…

fiddler抓包02_安装

① 访问官网&#xff1a;https://www.telerik.com/fiddler ② 点击“try for free”&#xff0c;选择经典版。 ③ 选择任意用途&#xff0c;输入邮箱&#xff0c;选择地区china&#xff0c;确定下载。 ④ 双击安装包进行安装。 安装后为英文界面&#xff1a;

nginx 文件尺寸过大解决方案

http { # 其他配置... client_max_body_size 1M; # 这是默认值&#xff0c;也可以在 server 块中覆盖 # 其他配置... } server { listen 80; server_name shop.yanmishu.cn; # 如果有这个配置&#xff0c;则会覆盖 http 块中的设置 …

借助大模型将文档转换为视频

利用传统手段将文档内容转换为视频&#xff0c;比如根据文档内容录制一个视频&#xff0c;不仅需要投入大量的时间和精力&#xff0c;而且往往需要具备专业的视频编辑技能。使用大模型技术可以更加有效且智能化地解决上述问题。本实践方案旨在依托大语言模型&#xff08;Large …

2024网络安全人才实战能力白皮书安全测试评估篇

9月10日&#xff0c;国内首个聚焦“安全测试评估”的白皮书——《网络安全人才实战能力白皮书-安全测试评估篇》&#xff08;以下简称“白皮书”&#xff09;在国家网络安全宣传周正式发布。 作为《网络安全人才实战能力白皮书》的第三篇章&#xff0c;本次白皮书聚焦“安全测…

基于react native的锚点

基于react native的锚点 效果示例图示例代码 效果示例图 示例代码 /* eslint-disable react-native/no-inline-styles */ import React, { useEffect, useRef, useState } from react; import {Image,ImageBackground,ScrollView,StyleSheet,Text,TouchableOpacity,View, } fr…

若依nday复现

前言 声明&#xff1a;此文章仅做学习&#xff0c;未经授权严禁转载。请勿利用文章内的相关技术从事非法测试&#xff0c;如因此产生的一切不良后果与文章作者无关 本文章只做简单汇总&#xff0c;在此感谢其他师傅的文章和分享 前置准备 环境搭建 下载&#xff1a;https:/…

微服务之间远程调用实现思路

项目使用的Spring Cloud Alibaba框架&#xff0c;微服务之间远程调用使用OpenFeign&#xff0c;具体实现步骤如下&#xff1a; &#xff08;1&#xff09;在api工程定义OpenFeign接口&#xff0c;使用FeignClient注解进行定义。 &#xff08;2&#xff09;服务提供方定义Open…

【FFmpeg应用场景概述】

Question FFmpeg应用场景概述 Answer FFmpeg是一个开源的音视频处理工具&#xff0c;广泛应用于多种场景。以下是一些常见的应用场景概述&#xff1a; 视频转码&#xff1a;FFmpeg支持多种音视频格式的转换&#xff0c;可以将视频文件从一种格式转换为另一种格式&#xff0c…

Vue基础明晰

Vue基础明晰 ​ Vue长期处于会写而不去理解&#xff0c;此文简单梳理一下。 ​ 一个Vue页面基本分为两部分&#xff1a;1.搜索、按钮等为主的表单域 2.展示数据库信息的表格域 Form表单&#xff1a; 一个Form表单其下为多个form-item&#xff0c;各搜索输入框都包裹在form-i…

HarmonyOS开发之使用Picker(从相册选择图片),并且通过Swiper组件实现图片预览

一&#xff1a;效果图&#xff1a; 二&#xff1a;添加依赖 import picker from ohos.file.picker; 三&#xff1a;创建showDialog showDialog() {AlertDialog.show({message: 从相册选择,alignment: DialogAlignment.Bottom,offset: { dx: 0, dy: -12 },primaryButton: {val…

pip安装包、卸载包、更新包命令

pip安装包、卸载包、更新包命令 pip命令具体说明备注pip list列出当前环境下已安装的包pip install [安装包名]安装指定包pip install SomePackage1.0.4安装指定版本pip uninstall [卸载包名]卸载指定包pip install --upgrade [要升级的包名称]升级指定包pip install -U [要升…

C++笔记---继承(下)

1. 无法被继承的类 要实现无法被继承的类有两种方式&#xff1a; C98及其之前&#xff1a;将父类的构造函数设置为private成员。 C11及其之后&#xff1a;使用final关键字修饰父类。 将构造函数设置为private是因为&#xff1a;子类的构成必须调用父类的构造函数&#xff0c;但…

C++学习笔记(26)

七 、显示字符串中的字符 从界面上输入一个字符串&#xff08;C 风格&#xff09;&#xff0c;把字符串中的每个字符显示出来&#xff0c;如果输入的是"abc"&#xff0c;要求&#xff1a; 1&#xff09;正序显示&#xff1a;a b c 2&#xff09;逆序显示&#xff1a;…

NC 矩阵最长递增路径

系列文章目录 文章目录 系列文章目录前言 前言 前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。点击跳转到网站&#xff0c;这篇文章男女通用&#xff0c;看懂了就去分享给你的码吧。 描述 给定一个 n 行…

【SQL】百题计划:SQL最基本的判断和查询。

[SQL]百题计划 Select product_id from Products where low_fats "Y" and recyclable "Y";

车辆重识别(关于卷积神经网络一些资料)2024/9/11

关于卷积神经网络的介绍 一&#xff0c;全连接神经网络 1&#xff0c;全连接神经网络的整体结构 X代表左边输入的数据&#xff08;向量或者矩阵等等&#xff09;&#xff0c;Y代表模型对数据处理之后的结果&#xff0c;中间的节点都可以算作为隐藏层。 2&#xff0c;全连接神经…