当前位置: 首页 > news >正文

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. 模板类也可以有支持继承,有层次关系,一个类模板可以作为基类,派生出派生模板类。

相关文章:

c++函数模板STL详解

函数模板 函数模板语法 所谓函数模板&#xff0c;实际上是建立一个通用函数&#xff0c;其函数类型和形参类型不具体指定&#xff0c;用一个虚拟的类型来代表。这个通用函数就称为函数模板。 凡是函数体相同的函数都可以用这个模板来代替&#xff0c;不必定义多个函数&#xf…...

Java利用UDP实现简单群聊

一、创建新项目 首先新建一个新的项目&#xff0c;并按如下操作 二、实现代码 界面ChatFrame类 package 群聊; import javax.swing.*; import java.awt.*; import java.awt.event.*; import java.net.InetAddress; public abstract class ChatFrame extends JFrame { p…...

fastapi.templating与HTMLResponse

要声明一个模板对象&#xff0c;应将存储html模板的文件夹作为参数提供。在当前工作目录中&#xff0c;我们将创建一个 “templates “目录。 templates Jinja2Templates(directory“templates”) 我们现在要把这个页面的HTML代码渲染成HTMLResponse。让我们修改一下hello()函…...

当初为什么选择计算机这类的行业?

CSDN给了这么一个话题&#xff1a; 还记得当初自己为什么选择计算机&#xff1f; 当初你问我为什么选择计算机&#xff0c;我笑着回答&#xff1a;“因为我梦想成为神奇的码农&#xff01;我想像编织魔法一样编写程序&#xff0c;创造出炫酷的虚拟世界&#xff01;”谁知道&…...

tif文件转png、Excel

l利用gdal读取tif中的地理信息和波段数组&#xff0c;然后保存想要的格式即可。 from osgeo import gdal from PIL import Image import numpy as np import cv2 as cv from matplotlib import pyplot as plt# 读取.tif文件 def read_tif(file_path):dataset gdal.Open(file_…...

【PyTorch】训练过程可视化

文章目录 1. 训练过程中的可视化1.1. alive_progress1.2. rich.progress 2. 训练结束后的可视化2.1. tensorboardX2.1.1. 安装2.1.2. 使用 1. 训练过程中的可视化 主要是监控训练的进度。 1.1. alive_progress 安装 pip install alive_progress使用 from alive_progress i…...

深入理解Go语言GC机制

1、Go 1.3之前的标记-清除&#xff08;mark and sweep&#xff09;算法 Go 1.3之前的时候主要用的是普通的标记-清除算法&#xff0c;此算法主要由两个主要的步骤&#xff1a; 标记&#xff08;Mark phase&#xff09;清除&#xff08;Sweep phase&#xff09; 1&#xff09…...

qt-C++笔记之组件-分组框QGroupBox

qt-C笔记之组件-分组框QGroupBox code review! 文章目录 qt-C笔记之组件-分组框QGroupBox1.《Qt 6 C开发指南》p752.《Qt 官方文档》3.《Qt 5.12实战》——5.9 分组框控件 1.《Qt 6 C开发指南》p75 2.《Qt 官方文档》 中间段落翻译&#xff1a; 我把示例补充完整&#xff1a; …...

qt 定时器用法

在qt开发中&#xff0c;定时器是我们经常用到的。我们接下来说一下定时器的三种用法&#xff0c;需要注意的是定时器事件是在主线程中触发的&#xff0c;因此在处理耗时操作时应特别小心&#xff0c;以避免阻塞应用程序的事件循环。 1. 三种定时器使用 1.1 QObject的定时器 …...

用23种设计模式打造一个cocos creator的游戏框架----(九)访问者模式

1、模式标准 模式名称&#xff1a;访问者模式 模式分类&#xff1a;行为型 模式意图&#xff1a;将数据操作与数据结构分离&#xff0c;使得在不修改数据结构的前提下&#xff0c;可以添加或改变对数据的操作。 结构图&#xff1a; 适用于&#xff1a; 当你需要对一个复杂对…...

根文件系统初步测试

一. 简介 上一篇文章学习了向所编译生成的根文件系统中加入 lib库文件。文章地址如下&#xff1a; 根文件系统lib库添加与初步测试-CSDN博客 本文继上一篇文章的学习&#xff0c;本文对之前制作的根文件系统进行一次初步测试。 二. 根文件系统初步测试 为了方便测试&#…...

【精选】设计模式——策略设计模式-两种举例说明,具体代码实现

Java策略设计模式 简介 策略设计模式是一种行为型设计模式&#xff0c;它允许在运行时选择算法的行为。 在软件开发中&#xff0c;我们常常需要根据不同情况采取不同的行为。通常的做法是使用大量的条件语句来实现这种灵活性&#xff0c;但这会导致代码变得复杂、难以维护和扩…...

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

先说情况&#xff0c;大专毕业&#xff0c;18年通过校招进入湖南某软件公司&#xff0c;干了接近6年的功能测试&#xff0c;今年年初&#xff0c;感觉自己不能够在这样下去了&#xff0c;长时间呆在一个舒适的环境会让一个人堕落!而我已经在一个企业干了四年的功能测试&#xf…...

微信小程序:chooseimage从本地相册选择图片或使用相机拍照

文档 https://uniapp.dcloud.net.cn/api/media/image.html#chooseimage https://developers.weixin.qq.com/miniprogram/dev/api/media/image/wx.chooseImage.html 代码示例 const res await uni.chooseImage({count: 1, //默认9sizeType: [original, compressed], //可以…...

「Swift」取消UITableView起始位置在状态栏下方开始

前言&#xff1a;在写页面UI时发现&#xff0c;当隐藏了NavigationBar时&#xff0c;即使UITableView是从(0,0)进行布局&#xff0c;也会一直在手机状态栏下方进行展示布局&#xff0c;而我的想法是希望UITableView可以从状态栏处就进行展示布局 当前页面展示&#xff1a; 问题…...

android高版本适配使用Tools.java

随着android版本的提升&#xff0c;原生Tools不公开并且不能被正常使用&#xff0c;为了延续项目的功能&#xff0c;修改如下&#xff1a; /** Copyright (C) 2006 The Android Open Source Project** Licensed under the Apache License, Version 2.0 (the "License&quo…...

面试官:说说webpack中常见的Loader?解决了什么问题?

面试官&#xff1a;说说webpack中常见的Loader&#xff1f;解决了什么问题&#xff1f; 一、是什么 loader 用于对模块的"源代码"进行转换&#xff0c;在 import 或"加载"模块时预处理文件 webpack做的事情&#xff0c;仅仅是分析出各种模块的依赖关系&a…...

【蓝桥杯省赛真题50】Scratch智能计价器 蓝桥杯scratch图形化编程 中小学生蓝桥杯省赛真题讲解

目录 scratch智能计价器 一、题目要求 编程实现 二、案例分析 1、角色分析...

折半查找(数据结构实训)

题目&#xff1a; 标准输入输出 题目描述&#xff1a; 实现折半查找。要求查找给定的值在数据表中相应的存储位置。本题目假定输入元素均按非降序输入。 输入&#xff1a; 输入包含若干个测试用例&#xff0c;第一行为测试用例个数k。每个测试用例占3行&#xff0c;其中第一行为…...

AR助推制造业智能转型:实时远程协作与可视化引领生产创新

制造商面临着多方面的变革&#xff0c;技术的兴起催生了工业物联网&#xff08;IIoT&#xff09;&#xff0c;改变了现代工厂的外貌、系统和流程。同时&#xff0c;全球竞争压力和不断变化的员工队伍要求采用新的员工培训方法&#xff0c;并重新审视工人在工厂中的角色。尽管如…...

Python爬虫实战:研究MechanicalSoup库相关技术

一、MechanicalSoup 库概述 1.1 库简介 MechanicalSoup 是一个 Python 库,专为自动化交互网站而设计。它结合了 requests 的 HTTP 请求能力和 BeautifulSoup 的 HTML 解析能力,提供了直观的 API,让我们可以像人类用户一样浏览网页、填写表单和提交请求。 1.2 主要功能特点…...

云原生核心技术 (7/12): K8s 核心概念白话解读(上):Pod 和 Deployment 究竟是什么?

大家好&#xff0c;欢迎来到《云原生核心技术》系列的第七篇&#xff01; 在上一篇&#xff0c;我们成功地使用 Minikube 或 kind 在自己的电脑上搭建起了一个迷你但功能完备的 Kubernetes 集群。现在&#xff0c;我们就像一个拥有了一块崭新数字土地的农场主&#xff0c;是时…...

<6>-MySQL表的增删查改

目录 一&#xff0c;create&#xff08;创建表&#xff09; 二&#xff0c;retrieve&#xff08;查询表&#xff09; 1&#xff0c;select列 2&#xff0c;where条件 三&#xff0c;update&#xff08;更新表&#xff09; 四&#xff0c;delete&#xff08;删除表&#xf…...

脑机新手指南(八):OpenBCI_GUI:从环境搭建到数据可视化(下)

一、数据处理与分析实战 &#xff08;一&#xff09;实时滤波与参数调整 基础滤波操作 60Hz 工频滤波&#xff1a;勾选界面右侧 “60Hz” 复选框&#xff0c;可有效抑制电网干扰&#xff08;适用于北美地区&#xff0c;欧洲用户可调整为 50Hz&#xff09;。 平滑处理&…...

令牌桶 滑动窗口->限流 分布式信号量->限并发的原理 lua脚本分析介绍

文章目录 前言限流限制并发的实际理解限流令牌桶代码实现结果分析令牌桶lua的模拟实现原理总结&#xff1a; 滑动窗口代码实现结果分析lua脚本原理解析 限并发分布式信号量代码实现结果分析lua脚本实现原理 双注解去实现限流 并发结果分析&#xff1a; 实际业务去理解体会统一注…...

Spring Boot+Neo4j知识图谱实战:3步搭建智能关系网络!

一、引言 在数据驱动的背景下&#xff0c;知识图谱凭借其高效的信息组织能力&#xff0c;正逐步成为各行业应用的关键技术。本文聚焦 Spring Boot与Neo4j图数据库的技术结合&#xff0c;探讨知识图谱开发的实现细节&#xff0c;帮助读者掌握该技术栈在实际项目中的落地方法。 …...

【Java_EE】Spring MVC

目录 Spring Web MVC ​编辑注解 RestController RequestMapping RequestParam RequestParam RequestBody PathVariable RequestPart 参数传递 注意事项 ​编辑参数重命名 RequestParam ​编辑​编辑传递集合 RequestParam 传递JSON数据 ​编辑RequestBody ​…...

AI编程--插件对比分析:CodeRider、GitHub Copilot及其他

AI编程插件对比分析&#xff1a;CodeRider、GitHub Copilot及其他 随着人工智能技术的快速发展&#xff0c;AI编程插件已成为提升开发者生产力的重要工具。CodeRider和GitHub Copilot作为市场上的领先者&#xff0c;分别以其独特的特性和生态系统吸引了大量开发者。本文将从功…...

NLP学习路线图(二十三):长短期记忆网络(LSTM)

在自然语言处理(NLP)领域,我们时刻面临着处理序列数据的核心挑战。无论是理解句子的结构、分析文本的情感,还是实现语言的翻译,都需要模型能够捕捉词语之间依时序产生的复杂依赖关系。传统的神经网络结构在处理这种序列依赖时显得力不从心,而循环神经网络(RNN) 曾被视为…...

华为云Flexus+DeepSeek征文|DeepSeek-V3/R1 商用服务开通全流程与本地部署搭建

华为云FlexusDeepSeek征文&#xff5c;DeepSeek-V3/R1 商用服务开通全流程与本地部署搭建 前言 如今大模型其性能出色&#xff0c;华为云 ModelArts Studio_MaaS大模型即服务平台华为云内置了大模型&#xff0c;能助力我们轻松驾驭 DeepSeek-V3/R1&#xff0c;本文中将分享如何…...