c++函数模板STL详解

函数模板

函数模板语法

所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。这个通用函数就称为函数模板。

凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现了不同函数的功能。

函数模板定义形式

由以下三部分组成： 模板说明 + 函数定义 + 函数模板调用

 template < 类型形式参数表 >类型  函数名 (形式参数表)
{//语句序列
}

1.模板说明

template <类型形式参数表>

类型形式参数的形式：

typename T1,typename T2,typename Tn……或class T1,class T2

(typename 和 class的效果完全相等)

2.函数定义

类型 函数名 (形式参数表)

{

}

**注意：**模板说明的类属参数必须在函数定义中出现一次

函数参数表中可以使用类属类型参数，也可以使用一般类型参数

3.模板函数调用

max<int>(a, b); //显式类型调用

max(a, b); //自动数据类型推导

4.函数模板

在这里插入图片描述

5.函数模板和函数重载

// demo 15-4.c
#include <iostream>
using namespace std;template <typename T>
void Swap(T &a, T &b){T t;t = a;a = b;b = t;cout<<"Swap 模板函数被调用了"<<endl;
}/*
void Swap(char &a, int &b){int  t;t = a;a = b;b = t;cout<<"Swap 普通函数被调用了"<<endl;
}
*/void main(void){char cNum = 'c';int iNum = 65;//第一种情况，模板函数和普通函数并存,参数类型和普通重载函数更匹配//调用普通函数//Swap(cNum, iNum);//第二种情况  不存在普通函数，函数模板会隐式数据类型转换嘛？//结论：不提供隐式的数据类型转换,必须是严格的匹配//Swap(cNum, iNum);system("pause");return ;
}

函数模板和普通函数区别结论：

两者允许并存

函数模板不允许自动类型转化

普通函数能够进行自动类型转换

// demo 15-5.c
#include <iostream>using namespace std;//第一版
int Max(int a, int b)
{cout<<"调用 int Max(int a, int b)"<<endl;return a>b ? a:b;
}template<typename T>
T Max(T a, T b)
{cout<<"调用 T Max(T a, T b)"<<endl;return a>b ? a:b;
}template <typename T>
T Max(T a, T b, T c){cout<<"调用 T Max(T a, T b, T c)"<<endl;return Max(Max(a, b), c);
}//第二版
int Max1(int a, int b)
{cout<<"调用 int Max(int a, int b)"<<endl;return a>b ? a:b;
}template<typename T1, typename T2>
T1 Max1(T1 a, T2 b)
{cout<<"调用 T Max1(T1 a, T2 b)"<<endl;return a>b ? a:b;
}void main(void){int a = 1;int b = 2;//当函数模板和普通函数都符合调用时,优先选择普通函数//cout<<"Max(a, b)"<<Max(a, b)<<endl;//如果显式的使用函数模板,则使用<> 类型列表//Max<>(a, b);char c = 'a';//如果函数模板会产生更好的匹配，使用函数模板//Max1(c, a);//Max(1.0, 2.0);Max(3.0, 4.0, 5.0);system("pause");return ;
}

函数模板和普通函数在一起，调用规则：

​ 1 函数模板可以像普通函数一样被重载

​ 2 C++编译器优先考虑普通函数

​ 3 如果函数模板可以产生一个更好的匹配，那么选择模板

​ 4 可以通过空模板实参列表的语法限定编译器只通过模板匹配

函数模板调用机制

// demo 15-6.c
#include <iostream>
using namespace std;template <typename T>
T Max(T a, T b){return a>b ? a:b;
}int main()
{int  x = 1;int	 y = 2;Max(x, y);float a = 2.0;float b = 3.0;Max(a, b);return 0;
}

*反汇编观察*

// demo.c
#include <iostream>
using namespace std;int Max(int a, int b){return a>b ? a:b;
}
int main()
{int  x = 1;int  y = 2;Max(x, y);return 0;
}

// demo.S.file   "demo.cpp".local  _ZStL8__ioinit.comm   _ZStL8__ioinit,1,1.text.globl  _Z3Maxii.type   _Z3Maxii, @function
_Z3Maxii:
.LFB1021:.cfi_startprocpushq   %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq    %rsp, %rbp.cfi_def_cfa_register 6movl    %edi, -4(%rbp)movl    %esi, -8(%rbp)movl    -4(%rbp), %eaxcmpl    -8(%rbp), %eaxjle     .L2movl    -4(%rbp), %eaxjmp     .L4
.L2:movl    -8(%rbp), %eax
.L4:popq    %rbp.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1021:.size   _Z3Maxii, .-_Z3Maxii.globl  main.type   main, @function
main:
.LFB1022:.cfi_startprocpushq   %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq    %rsp, %rbp.cfi_def_cfa_register 6subq    $16, %rspmovl    $1, -8(%rbp)movl    $2, -4(%rbp)movl    -4(%rbp), %edxmovl    -8(%rbp), %eaxmovl    %edx, %esimovl    %eax, %edicall    _Z3Maxiimovl    $0, %eaxleave.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1022:.size   main, .-main.type   _Z41__static_initialization_and_destruction_0ii, @function
_Z41__static_initialization_and_destruction_0ii:
.LFB1023:.cfi_startprocpushq   %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq    %rsp, %rbp.cfi_def_cfa_register 6subq    $16, %rspmovl    %edi, -4(%rbp)movl    %esi, -8(%rbp)cmpl    $1, -4(%rbp)jne     .L9cmpl    $65535, -8(%rbp)jne     .L9movl    $_ZStL8__ioinit, %edicall    _ZNSt8ios_base4InitC1Evmovl    $__dso_handle, %edxmovl    $_ZStL8__ioinit, %esimovl    $_ZNSt8ios_base4InitD1Ev, %edicall    __cxa_atexit
.L9:nopleave.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1023:.size   _Z41__static_initialization_and_destruction_0ii, .-_Z41__static_initialization_and_destruction_0ii.type   _GLOBAL__sub_I__Z3Maxii, @function
_GLOBAL__sub_I__Z3Maxii:
.LFB1024:.cfi_startprocpushq   %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq    %rsp, %rbp.cfi_def_cfa_register 6movl    $65535, %esimovl    $1, %edicall    _Z41__static_initialization_and_destruction_0iipopq    %rbp.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1024:.size   _GLOBAL__sub_I__Z3Maxii, .-_GLOBAL__sub_I__Z3Maxii.section        .init_array,"aw".align 8.quad   _GLOBAL__sub_I__Z3Maxii.hidden __dso_handle.ident  "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.5) 5.4.0 20160609".section        .note.GNU-stack,"",@progbits
// demo_06.cpp
#include <iostream>
using namespace std;template <typename T>
T Max(T a, T b){return a>b ? a:b;
}int main()
{int  x = 1;int	 y = 2;Max(x, y);float a = 2.0;float b = 3.0;Max(a, b);return 0;
}

g++ -S demo_06.cpp -o demo.S

// demo_06.S.file   "demo_06.cpp".local  _ZStL8__ioinit.comm   _ZStL8__ioinit,1,1.text.globl  main.type   main, @function
main:
.LFB1022:.cfi_startprocpushq   %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq    %rsp, %rbp.cfi_def_cfa_register 6subq    $32, %rspmovl    $1, -16(%rbp)movl    $2, -12(%rbp)movl    -12(%rbp), %edxmovl    -16(%rbp), %eaxmovl    %edx, %esimovl    %eax, %edicall    _Z3MaxIiET_S0_S0_movss   .LC0(%rip), %xmm0movss   %xmm0, -8(%rbp)movss   .LC1(%rip), %xmm0movss   %xmm0, -4(%rbp)movss   -4(%rbp), %xmm0movl    -8(%rbp), %eaxmovaps  %xmm0, %xmm1movl    %eax, -20(%rbp)movss   -20(%rbp), %xmm0call    _Z3MaxIfET_S0_S0_movl    $0, %eaxleave.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1022:.size   main, .-main.section        .text._Z3MaxIiET_S0_S0_,"axG",@progbits,_Z3MaxIiET_S0_S0_,comdat.weak   _Z3MaxIiET_S0_S0_.type   _Z3MaxIiET_S0_S0_, @function
_Z3MaxIiET_S0_S0_:
.LFB1023:.cfi_startprocpushq   %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq    %rsp, %rbp.cfi_def_cfa_register 6movl    %edi, -4(%rbp)movl    %esi, -8(%rbp)movl    -4(%rbp), %eaxcmpl    -8(%rbp), %eaxjle     .L4movl    -4(%rbp), %eaxjmp     .L6
.L4:movl    -8(%rbp), %eax
.L6:popq    %rbp.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1023:.size   _Z3MaxIiET_S0_S0_, .-_Z3MaxIiET_S0_S0_.section        .text._Z3MaxIfET_S0_S0_,"axG",@progbits,_Z3MaxIfET_S0_S0_,comdat.weak   _Z3MaxIfET_S0_S0_.type   _Z3MaxIfET_S0_S0_, @function
_Z3MaxIfET_S0_S0_:
.LFB1024:.cfi_startprocpushq   %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq    %rsp, %rbp.cfi_def_cfa_register 6movss   %xmm0, -4(%rbp)movss   %xmm1, -8(%rbp)movss   -4(%rbp), %xmm0ucomiss -8(%rbp), %xmm0jbe     .L13movss   -4(%rbp), %xmm0jmp     .L11
.L13:movss   -8(%rbp), %xmm0
.L11:popq    %rbp.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1024:.size   _Z3MaxIfET_S0_S0_, .-_Z3MaxIfET_S0_S0_.text.type   _Z41__static_initialization_and_destruction_0ii, @function
_Z41__static_initialization_and_destruction_0ii:
.LFB1025:.cfi_startprocpushq   %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq    %rsp, %rbp.cfi_def_cfa_register 6subq    $16, %rspmovl    %edi, -4(%rbp)movl    %esi, -8(%rbp)cmpl    $1, -4(%rbp)jne     .L16cmpl    $65535, -8(%rbp)jne     .L16movl    $_ZStL8__ioinit, %edicall    _ZNSt8ios_base4InitC1Evmovl    $__dso_handle, %edxmovl    $_ZStL8__ioinit, %esimovl    $_ZNSt8ios_base4InitD1Ev, %edicall    __cxa_atexit
.L16:nopleave.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1025:.size   _Z41__static_initialization_and_destruction_0ii, .-_Z41__static_initialization_and_destruction_0ii.type   _GLOBAL__sub_I_main, @function
_GLOBAL__sub_I_main:
.LFB1026:.cfi_startprocpushq   %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq    %rsp, %rbp.cfi_def_cfa_register 6movl    $65535, %esimovl    $1, %edicall    _Z41__static_initialization_and_destruction_0iipopq    %rbp.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1026:.size   _GLOBAL__sub_I_main, .-_GLOBAL__sub_I_main.section        .init_array,"aw".align 8.quad   _GLOBAL__sub_I_main.section        .rodata.align 4
.LC0:.long   1073741824.align 4
.LC1:.long   1077936128.hidden __dso_handle.ident  "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.5) 5.4.0 20160609".section        .note.GNU-stack,"",@progbits

结论：

  1. 编译器并不是把函数模板处理成能够处理任意类型的函数
  2. 编译器从函数模板通过具体类型产生不同的函数

类模板的使用

为什么需要类模板

1.为什么需要类模板

类模板与函数模板的定义和使用类似，有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同，我们可以通过如下面语句声明了一个类模板：

// demo 15-7.c
template <typename T>
class A
{
public:A(T t){this->t = t;}T &getT(){return t;}public:T t;
};

Ø 类模板用于实现类所需数据的类型参数化

Ø 类模板在表示支持多种数据结构显得特别重要，这些数据结构的表示和算法不受所包含的元素类型的影响

类模板的定义

类模板由模板说明和类说明构成

模板说明同函数模板，如下：

​ *template* <类型形式参数表>

​ 类声明

例如：

template

class ClassName

{

//ClassName 的成员函数

private ：

Type DataMember;

}

单个类模板的使用

// demo 15-8.c
#include <iostream>using namespace std;template <typename T>
class A
{
public://函数的参数列表使用虚拟类型A(T t=0){this->t = t;}//成员函数返回值使用虚拟类型T &getT(){return t;}private://成员变量使用虚拟类型T t;
};void printA(A<int> &a){cout<<a.getT()<<endl;
}int main(void){//1.模板类定义类对象，必须显示指定类型//2.模板种如果使用了构造函数，则遵守以前的类的构造函数的调用规则A<int>  a(666);cout<<a.getT()<<endl;//模板类做为函数参数printA(a);system("pause");return 0;
}

继承中类模板的使用

// demo 15-9.c
#include <iostream>using namespace std;//继承中父子类和模板类的结合情况
//1.父类一般类，子类是模板类, 和普通继承的玩法类似
//2.子类是一般类，父类是模板类,继承时必须在子类里实例化父类的类型参数
//3.父类和子类都时模板类时，子类的虚拟的类型可以传递到父类中/*class B
{
public:B(int b){this->b = b;}private:int b;
};
*/template <typename T>
class A
{
public://函数的参数列表使用虚拟类型A(T t){this->t = t;}//成员函数返回值使用虚拟类型T &getT(){return t;}private://成员变量使用虚拟类型T t;
};template <typename Tb>
class B: public A<int>
{public:B(Tb b):A<Tb>(b){this->b = b;}private:Tb b;};void printA(A<int> &a){cout<<a.getT()<<endl;
}int main(void){//1.模板类定义类对象，必须显示指定类型//2.模板种如果使用了构造函数，则遵守以前的类的构造函数的调用规则A<int>  a(666);cout<<a.getT()<<endl;B<int> b(888);cout<<"b(888): "<<b.getT()<<endl;//模板类做为函数参数printA(a);system("pause");return 0;
}

结论: 子类从模板类继承的时候,需要让编译器知道 父类的数据类型具体是什么

1.父类一般类，子类是模板类, 和普通继承的玩法类似

2.子类是一般类，父类是模板类,继承时必须在子类里实例化父类的类型参数

3.父类和子类都时模板类时，子类的虚拟的类型可以传递到父类中

类模板的三种表述方式

所有的类模板函数写在类的外部，在一个cpp中

// demo 15-9.c
#include <iostream>using namespace std;template <typename T>
class A
{
public:A(T t=0);T &getT();A operator +(const A &other);void print();private:T t;
};/*
class A
{
public:A(int t=0);int &getT();A operator +(const A &other);void print();private:int t;
};
*/template <typename T>
A<T>::A(T t)
{this->t = t;
}template <typename T>
T &A<T>::getT(){return t;}template <typename T>
A<T> A<T>::operator+(const A<T> &other){A<T> tmp; //类的内部类型可以显示声明也可以不显示tmp.t =this->t + other.t;return tmp;}template <typename T>
void A<T>::print(){cout<<this->t<<endl;
}int main(void){A<int>  a(666), b(888);//cout<<a.getT()<<endl;A<int> tmp = a + b;tmp.print();system("pause");return 0;
}

总结

在同一个cpp 文件中把模板类的成员函数放到类的外部，需要注意以下几点

  • 函数前声明 *template* <类型形式参数表>

  • 类的成员函数前的类限定域说明必须要带上虚拟参数列表

  • 返回的变量是模板类的对象时必须带上虚拟参数列表

  • 成员函数参数中出现模板类的对象时必须带上虚拟参数列表

  • 成员函数内部没有限定

所有的类模板函数写在类的外部，在不同的.h和.cpp中

// demo.h
#pragma oncetemplate <typename T>
class A
{
public:A(T t=0);T &getT();A operator +(const A &other);void print();private:T t;
};
// demo 15-10.c
#include "demo.h"
#include <iostream>using namespace std;template <typename T>
A<T>::A(T t)
{this->t = t;
}template <typename T>
T &A<T>::getT(){return t;}template <typename T>
A<T> A<T>::operator+(const A<T> &other){A<T> tmp; //类的内部类型可以显示声明也可以不显示tmp.t =this->t + other.t;return tmp;}template <typename T>
void A<T>::print(){cout<<this->t<<endl;
}int main(void){A<int>  a(666), b(888);//cout<<a.getT()<<endl;A<int> tmp = a + b;tmp.print();system("pause");return 0;
}

****注意：****当类模板的声明(.h文件)和实现(.cpp 或.hpp文件)完全分离，因为类模板的特殊实现，我们应在使用类模板时使用#include 包含 实现部分的.cpp 或.hpp文件。

特殊情况- 友元函数

// demo 15-11.c
#include <iostream>using namespace std;template <typename T>
class A
{
public:A(T t=0);//声明一个友元函数，实现对两个A类对象进行加法操作template <typename T>friend A<T> addA(const A<T> &a, const A<T> &b);T &getT();A operator +(const A &other);void print();private:T t;
};template <typename T>
A<T>::A(T t)
{this->t = t;
}template <typename T>
T &A<T>::getT(){return t;}template <typename T>
A<T> A<T>::operator+(const A<T> &other){A tmp; //类的内部类型可以显示声明也可以不显示tmp.t =this->t + other.t;return tmp;}template <typename T>
void A<T>::print(){cout<<this->t<<endl;
}//A 类的友元函数,就是它的好朋友
template <typename T>
A<T> addA(const A<T> &a, const A<T> &b){A<T> tmp;cout<<"call addA()..."<<endl;tmp.t = a.t + b.t;return tmp;
}int main(void){A<int>  a(666), b(888);//cout<<a.getT()<<endl;A<int> tmp = a + b;A<int> tmp1 = addA<int>(a, b);tmp.print();tmp1.print();system("pause");return 0;
}

在这里插入图片描述

模板类和静态成员

// demo 15-12.c
#include <iostream>using namespace std;template <typename T>
class A
{
public:A(T t=0);T &getT();A operator +(const A &other);void print();public:static int count;
private:T t;
};template <typename T> int A<T>::count = 666;template <typename T>
A<T>::A(T t)
{this->t = t;
}template <typename T>
T &A<T>::getT()
{return t;
}template <typename T>
A<T> A<T>::operator+(const A<T> &other){A tmp; //类的内部类型可以显示声明也可以不显示tmp.t =this->t + other.t;return tmp;
}template <typename T>
void A<T>::print(){cout<<this->t<<endl;
}/*
//当我们的虚拟的类型T被 int 实例化以后，模板类如下：
class A
{
public:
A(int t=0);int &getT();A operator +(const A &other);void print();public:
static int count;
private:
int t;
};int A::count = 666;A::A(int t)
{
this->t = t;
}int &A::getT()
{
return t;
}A A::operator+(const A &other){
A tmp; //类的内部类型可以显示声明也可以不显示
tmp.t =this->t + other.t;
return tmp;
}void A::print(){
cout<<this->t<<endl;
}
*//*
//当我们的虚拟的类型T被 float 实例化以后，模板类如下：
class A
{
public:
A(float t=0);float &getT();A operator +(const A &other);void print();public:
static int count;
private:
float t;
};int A::count = 666;A::A(float t)
{
this->t = t;
}float &A::getT()
{
return t;
}A A::operator+(const A &other){
A tmp; //类的内部类型可以显示声明也可以不显示
tmp.t =this->t + other.t;
return tmp;
}void A::print(){
cout<<this->t<<endl;
}
*/int main(void){A<int>  a(666), b(888);A<int> tmp = a + b;//A  a(666), b(888);//A tmp = a + b;A<float> c(777), d(999);a.count = 888;cout<<"b.count:"<<b.count<<endl;cout<<"c.count:"<<c.count<<endl;cout<<"d.count:"<<d.count<<endl;c.count = 1000;cout<<"修改后, d.count:"<<d.count<<endl;//tmp.print();system("pause");return 0;
}

类模板使用总计

归纳以上的介绍，可以这样声明和使用类模板：

  1. 先写出一个实际的类。

  2. 将此类中准备改变的类型名(如int要改变为float或char)改用一个自己指定的虚拟类型名(如上例中的T)。

  3. 在类声明前面加入一行，格式为：

    template <typename 虚拟类型参数>

​ 如：

 template <typename numtype> class A{…}; //类体

  1. 用类模板定义对象时用以下形式：

    类模板名<实际类型名> 对象名;

    或 类模板名<实际类型名> 对象名(实参表列);

​ 如：

A<int> cmp;A<int> cmp(3,7);

  1. 如果在类模板外定义成员函数，应写成类模板形式：

    template <typename 虚拟类型参数>

    函数类型 类模板名<虚拟类型参数>::成员函数名(函数形参表列) { …}

关于类模板的几点 补充

  1. 类模板的类型参数可以有一个或多个，每个类型前面都必须加typename 或class，如：

    template <typename T1,typename T2>

    class someclass

    {…};

​ 在定义对象时分别代入实际的类型名，如：

 someclass<int, char> object;

  1. 和使用类一样，使用类模板时要注意其作用域，只有在它的有效作用域内用使用它定义对象。

  2. 模板类也可以有支持继承，有层次关系，一个类模板可以作为基类，派生出派生模板类。

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

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

相关文章

外包干了3个月，技术倒退2年。。。

外包干了3个月，技术倒退2年。。。

先说情况&#xff0c;大专毕业&#xff0c;18年通过校招进入湖南某软件公司&#xff0c;干了接近6年的功能测试&#xff0c;今年年初&#xff0c;感觉自己不能够在这样下去了&#xff0c;长时间呆在一个舒适的环境会让一个人堕落!而我已经在一个企业干了四年的功能测试&#xf…
阅读更多...
轻量封装WebGPU渲染系统示例＜40＞- 多层材质的Mask混合(源码)

轻量封装WebGPU渲染系统示例＜40＞- 多层材质的Mask混合(源码)

当前示例源码github地址: https://github.com/vilyLei/voxwebgpu/blob/feature/rendering/src/voxgpu/sample/MaskTextureEffect.ts 当前示例运行效果: 两层材质效果: 三层材质效果: 此示例基于此渲染系统实现&#xff0c;当前示例TypeScript源码如下&#xff1a; export c…
阅读更多...
rename--统一的PRF

rename--统一的PRF

基本概念 将ARF/PRF进行合并&#xff0c;合同之后的不见&#xff0c;称之为统一的PRF(Physical Register File);存储的是speculative的&#xff0c;以及正确的&#xff08;retire&#xff09;寄存器值&#xff1b; 使用free list&#xff0c;存储PRF中&#xff0c;哪些寄存器是…
阅读更多...
布隆过滤器及其在Java中的实际应用

布隆过滤器及其在Java中的实际应用

前言 布隆过滤器一直是面试中的重点&#xff0c;本篇文章将深入探讨Java中的布隆过滤器的底层思想&#xff0c;包括它的工作原理、优缺点等。同时&#xff0c;我们将结合一个小实际案例&#xff0c;来给大家展示布隆过滤器在解决实际问题中的应用。 布隆过滤器简单介绍 在数…
阅读更多...
一对一互相聊天

一对一互相聊天

服务端 package 一对一用户;import java.awt.BorderLayout; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; import java.util.Vector;…
阅读更多...
【自动化测试】pytest 用例执行中print日志实时输出

【自动化测试】pytest 用例执行中print日志实时输出

author: jwensh date: 20231130 pycharm 中 pytest 用例执行中 print 日志 standout 实时命令行输出 使用场景 在进行 websocket 接口进行测试的时候&#xff0c;希望有一个 case 是一直执行并接受接口返回的数据 def on_message(ws, message):message json.loads(message)…
阅读更多...
计算UDP报文CRC校验的总结

计算UDP报文CRC校验的总结

概述 因公司项目需求&#xff0c;遇到需要发送带UDP/IP头数据包的功能&#xff0c;经过多次尝试顺利完成&#xff0c;博文记录以备忘。 环境信息 操作系统 ARM64平台的中标麒麟Kylin V10 工具 tcpdump、wireshark、vscode 原理 请查看大佬的博文 UDP伪包头定义&#x…
阅读更多...
2023年第十六届山东省职业院校技能大赛中职组“网络安全”赛项竞赛正式试题

2023年第十六届山东省职业院校技能大赛中职组“网络安全”赛项竞赛正式试题

第十六届山东省职业院校技能大赛中职组 “网络安全”赛项竞赛试题 目录 一、竞赛时间 二、竞赛阶段 三、竞赛任务书内容 &#xff08;一&#xff09;拓扑图 &#xff08;二&#xff09;A模块基础设施设置/安全加固&#xff08;200分&#xff09; &#xff08;三&#xf…
阅读更多...
Docker安装Elasticsearch以及ik分词器

Docker安装Elasticsearch以及ik分词器

Elasticsearch 是一个分布式、RESTful 风格的搜索和数据分析引擎&#xff0c;能够解决不断涌现出的各种用例。作为 Elastic Stack 的核心&#xff0c;Elasticsearch 会集中存储您的数据&#xff0c;让您飞快完成搜索&#xff0c;微调相关性&#xff0c;进行强大的分析&#xff…
阅读更多...
C#图像处理OpenCV开发指南（CVStar，07）——通用滤波（Filter2D）的实例代码

C#图像处理OpenCV开发指南（CVStar，07）——通用滤波（Filter2D）的实例代码

1 函数定义 void Filter2D (Mat src, Mat dst, int ddepth, InputArray kernel, Point anchor Point(-1,-1), double delta 0, int borderType BORDER_DEFAULT ) 1.1 原型 #include <opencv2/imgproc.hpp> Convolves an image wit…
阅读更多...
【msg_msg】corCTF2021-msgmsg 套题

【msg_msg】corCTF2021-msgmsg 套题

前言 该套题共两题&#xff0c;一道简单模式 fire_of_salvation&#xff0c;一道困难模式 wall_of_perdition&#xff0c;都是关于 msg_msg 的利用的。这题跟之前的 TPCTF2023 core 的很像&#xff08;应该是 TPCTF2023 core 跟他很像&#xff0c;bushi&#xff09;。 其中 f…
阅读更多...
Elasticsearch：什么是大语言模型（LLM）？

Elasticsearch：什么是大语言模型（LLM）？

大语言模型定义 大语言模型 (LLM) 是一种深度学习算法&#xff0c;可以执行各种自然语言处理 (natural language processing - NLP) 任务。 大型语言模型使用 Transformer 模型&#xff0c;并使用大量数据集进行训练 —— 因此规模很大。 这使他们能够识别、翻译、预测或生成文…
阅读更多...
Linux 存储管理

Linux 存储管理

内容概述 磁盘结构分区类型管理分区管理文件系统挂载设备管理swap空间&#xff08;用来缓解内存空间不足情况&#xff09;RAID 管理LVM管理LVM快照 1 磁盘结构 1.1 设备文件 块设备文件&#xff1a;数据的访问单位是块Block&#xff0c;一个块的IO 字符设备文件&#xff1a…
阅读更多...
springboot 整合security并且配置swagger 时，无法访问/doc.html

springboot 整合security并且配置swagger 时，无法访问/doc.html

参考文档&#xff1a; https://blog.csdn.net/qq_43340419/article/details/120312937解决方案&#xff1a;需要在WebSecurityConfig 中 配置允许匿名访问的路径 .antMatchers("/v2/api-docs","/swagger-resources/configuration/ui","/swagger-res…
阅读更多...
备忘录模式 rust和java的实现

备忘录模式 rust和java的实现

文章目录 备忘录模式介绍实现javarustrust仓库 备忘录模式 备忘录&#xff08;Memento&#xff09;模式的定义&#xff1a;在不破坏封装性的前提下&#xff0c;捕获一个对象的内部状态&#xff0c;并在该对象之外保存这个状态&#xff0c;以便以后当需要时能将该对象恢复到原先…
阅读更多...
设计模式——七大设计原则

设计模式——七大设计原则

设计模式——七大设计原则 1、单一职责原则&#xff08;SRP&#xff09;2、开放封闭原则&#xff08;OCP&#xff09;3、依赖倒转原则&#xff08;DIP&#xff09;4、里氏替换原则 (LSP)5、接口隔离原则 (ISP)6、合成/聚合复用原则 (CARP)7、迪米特法则 (LoD) 了解 设计模式 的…
阅读更多...
Qt/C++音视频开发57-切换音视频轨道/切换节目流/分别切换音频视频轨道

Qt/C++音视频开发57-切换音视频轨道/切换节目流/分别切换音频视频轨道

一、前言 对各种音视频文件格式的支持&#xff0c;是一个播放器的基础功能。一般的音视频文件只有1路流&#xff0c;比如音频文件只有1路音频流&#xff0c;视频文件只有1路音频1路视频流&#xff0c;实践过程中发现&#xff0c;还有一种ts格式的文件&#xff0c;可能有多路流…
阅读更多...
Python包管理器PIP用法大全

Python包管理器PIP用法大全

pip是Python的包管理器&#xff0c;用于安装和管理Python包。以下是一些常用的基本的pip命令&#xff0c;分享给大家&#xff0c;希望对大家使用pip有所帮助。 文章目录 pip installpip uninstallpip listpip searchpip downloadpip configpip freezepip checkpip wheelpip ha…
阅读更多...
网络安全攻击预警/态势预测算法汇总

网络安全攻击预警/态势预测算法汇总

总结&#xff1a; 网络安全攻击预警/态势预测算法众多&#xff0c;主要包括&#xff1a; 基于统计学的算法&#xff1a;协方差矩阵、马尔可夫模型等&#xff1b; 基于机器学习的算法&#xff1a;贝叶斯网络、聚类算法、支持向量机SVM、遗传算法、层次分析法AHP、决策树等&am…
阅读更多...
Matlab 曲线动态绘制

Matlab 曲线动态绘制

axes(handles.axes1); % 选定所画坐标轴 figure也可 h1 animatedline; h1.Color b; h1.LineWidth 2; h1.LineStyle -; % 线属性设置 for i 1 : length(x)addpoints(h1,x(i),y(i)); % x/y为待绘制曲线数据drawnow;pause(0.01); % 画点间停顿 end 示例&#xff1a; figure…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023