10 【C++】泛型编程

文章目录

  • 前言
  • 泛型编程（模板）
    • 1. 函数模板
      • 1.1 函数模板格式
      • 1.2 函数模板的实例化
        • 隐式实例化
        • 显式指定模板参数实例化
      • 1.3 函数模板实例化的原理
      • 1.4 模板参数的匹配原则
    • 2. 类模板
      • 2.1 类模板的格式
      • 2.2 类模板的实例化
      • 2.3 类模板实例化的原理
      • 2.4 类模板的匹配原则
  • 模板的特化
    • 3. 函数模板特化
    • 4. 类模板特化
      • 4.1 全特化
      • 4.2 偏特化
      • 4.3 类模板特化应用示例
  • 模板分离编译
    • 5.什么是分离编译
      • 5.1 函数模板的分离编译
      • 5.2 类模板的分离编译
  • 非类型模板参数
  • 模板优缺
  • 总结

前言

通过00【C++ 入门基础】前言得知，C++是为了解决C语言在面对大型项目的局限而诞生：

C语言面对的现实工程问题（复杂性、可维护性、可扩展性、安全性）

C语言面临的具体问题：

struct 数据公开暴露，函数数据分离，逻辑碎片化。（复杂性、安全性）
修改数据结构，如 struct 新增字段，可能导致大量相关函数需要修改。（可维护性）
添加新功能常需修改现有函数或结构体，易引入错误。（可扩展性）
资源（内存、文件句柄）需手动管理，易泄漏或重复释放。(安全性)

之前我们知道了，函数重载，可以帮我们解决：类似功能（加法）的函数命名域污染问题，这解决了我们代码的复杂性问题，但是没有很好的实现对代码的复用性。

本文讲解的泛型编程，就是C++用于对代码复用、代码可维护性、类型安全的手段之一，不仅对于函数，对于类也可以。

泛型编程（模板）

我们尝试实现一个简单的交换函数：

void Swap(int& left, int& right)
{int temp = left;left = right;right = temp;
}
void Swap(double& left, double& right)
{double temp = left;left = right;right = temp;
}
void Swap(char& left, char& right)
{char temp = left;left = right;right = temp;
}

我们可以根据参数类型不同，重载多个功能相同的同名函数，命名重复的问题我们通过函数重载的问题解决了，但是有多少个类似的应用场景，我们就需要手动的实现多少个，所以它就有以下一些不好的地方：

  1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数。
  2. 代码的可维护性比较低，一个出错可能所有的重载均出错。

那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？
在这里插入图片描述
如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件(即生成具体类型的代码），那将会节省许多头发。
这个“模具”（函数模版、类模版），就是我们要编写的通用代码，最终我们通过传不同的参数，让编译器自动生成对应的“铸件”（函数、类）。

泛型编程：编写与类型无关的通用代码，最终是代码复用的一种手段。模板是泛型编程的基础。
在这里插入图片描述

1. 函数模板

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

1.1 函数模板格式

template<typename T1, typename T2,…,typename Tn>
返回值类型 函数名(参数列表){}

现在我们使用函数模版，再去实现一个交换函数：

template<typename T>
void Swap( T& left, T& right)
{T temp = left;left = right;right = temp;
}

注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

1.2 函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

注意：与我们类从类型去实例化出一个对象不同，函数模版的实例化，是从模版实例化出一个函数。

隐式实例化

让编译器根据实参推演模板参数的实际类型。

template<class T>
T Add(const T& left, const T& right)
{return left + right;
}
int main()
{int a1 = 10, a2 = 20;double d1 = 10.0, d2 = 20.0;Add(a1, a2);Add(d1, d2);/*该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅Add(a1, d1);*/// 此时有两种处理方式：// 1. 用户自己来强制转化Add(a1, (int)d1); // 2. 使用显式实例化//TODO...return 0;
}
显式指定模板参数实例化

在函数名后的<>中指定模板参数的实际类型，相当于给模版传一个类型参数。

template<class T>
T Add(const T& left, const T& right)
{return left + right;
}
int main()
{int a = 10;double b = 20.0;// 显式传参实例化Add<int>(a, b);return 0;
}

如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

1.3 函数模板实例化的原理

函数模板是一个蓝图，它本身并不是函数，是我们写给编译器看的模具，最终编译器再根据我们给这个模具传入的材料（类型），去生成最终的函数。

所以其实模板就是将本来应该我们做的重复的事情（重复实现多个功能类似的函数）交给了编译器去做。

函数的隐式实例化：
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。
比如：当用double类型的参数传入函数模板使用时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

在这里插入图片描述
我们知道普通的一个函数调用，编译器会根据AST树的域节点向上查找，直到找到与调用处函数名称相同的声明，然后根据函数的参数，生成唯一的函数符号，这个函数符号将会持续到链接过程。但是我们的模板呢？

如果编译器找到与函数调用处同名的是一个函数模板，那么如果遇到函数的模版,编译器就会根据函数调用处的参数，自动的推导出这个函数的声明,并自动生成这个函数的定义,然后给函数调用处推导出一个符号，这个符号照样会持续到链接过程，最终由链接器，生成不同的函数地址：
在这里插入图片描述

显式指定模板参数实例化：
实例化行为与隐式推导完全相同，只是显示传入参数。

1.4 模板参数的匹配原则

我们知道编译器会自动去查找到函数调用处同名的函数声明或者定义，其实如果有多个同名，它会怎么办呢？

编译器的处理步骤：​​

  1. ​名称查找​：
    编译器在main函数中看到MyNS::foo(42)。
    它首先解析MyNS命名空间，然后在MyNS的作用域内查找名为foo的所有函数。
    它成功找到了三个候选函数：#1, #2, #3。至此，名称查找完成。

  2. 重载解析​：
    编译器开始分析调用foo(42)，实参是int类型的42。
    它将实参int(42)与每个候选函数的形参进行匹配：
    ​匹配 #1 foo(int)​​：​精确匹配​！不需要任何转换。这是最好的情况。
    ​匹配 #2 foo(double)​​：需要标准转换​（int-> double）。匹配度良好，但不如精确匹配。
    匹配 #3 foo(char)​​：需要标准转换​（int-> char）。但这是一个窄化转换（可能丢失信息），在重载解析中优先级通常低于提升或标准算术转换，几乎不会被选择。
    ​匹配 #4 template foo(T)​​：通过模板转换成foo(int)。匹配度良好，但不如精确匹配。

结果​：编译器确定#1是最佳匹配。

  1. 代码生成​：一旦重载解析完成，编译器就确切地知道该调用哪个函数了。
    ​此时，编译器才会根据这个具体函数的签名（名称+参数类型）去进行名称修饰，生成一个唯一的链接符号（例如，_ZN4MyNS3fooEi可能代表MyNS::foo(int)）。
    此时如何选中模板，就会根据模板和选中的参数生成代码，
    这个修饰后的符号会被写入目标文件，链接器后续会使用它来找到函数的定义。

其实编译器在查找的时候，会找到所有与函数调用处同名的候选者，编译器会把所有找到的同名函数（无论参数如何）都加入到候选列表中，最后选举出与调用处最匹配的函数，如果选的是普通函数就正常的生成符号，并在调用处（Call）生成的符号；如果选的是模板就根据类型生成定义然后再在调用处生成（Call）符号。

（1）一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

// 专门处理int的加法函数
int Add(int left, int right)
{return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{return left + right;
}
void Test()
{Add(1, 2); // 与非模板函数匹配，编译器不需要特化Add<int>(1, 2); // 调用编译器特化的Add版本
}

（2）对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

// 专门处理int的加法函数
int Add(int left, int right)
{return left + right;
}// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{return left + right;
}
void Test()
{Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}

（3）模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
说的是我们模板函数接收的类型参数不可以私自转换，但是我们普通函数接受的参数，可以强转为别的类型。

2. 类模板

2.1 类模板的格式

template<class T1, class T2, ..., class Tn>
class 类模板名
{// 类内成员定义
};

2.2 类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

// 动态顺序表
// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
template<class T>
class Vector
{
public:Vector(size_t capacity = 10): _pData(new T[capacity]), _size(0), _capacity(capacity){}// 使用析构函数演示：在类中声明，在类外定义。~Vector();void PushBack(const T& data)；void PopBack()；// ...size_t Size() { return _size; }T& operator[](size_t pos){assert(pos < _size);return _pData[pos];}private:T* _pData;size_t _size;size_t _capacity;
};
// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template <class T>
Vector<T>::~Vector()
{if (_pData)delete[] _pData;_size = _capacity = 0;
}// Vector类名，Vector<int>才是类型
int main()
{Vector<int> s1;Vector<double> s2;
}

2.3 类模板实例化的原理

类模板的实例化和函数的显示实例化原理相似，编译器通过名称的查找到同名类型，然后通过显示传入的参数，去生成对应的实体代码。

2.4 类模板的匹配原则

类模板的成员函数（尤其是构造函数）在调用时，会经历与函数模板非常相似的重载解析和实例化过程，但类模板本身也有一些特殊性。​​

  1. 类模板实例化 vs 成员函数调用：​​
    ​类模板实例化：​​ 当你使用一个类模板时（如 MyClass obj;），编译器会根据提供的模板参数（int）​实例化整个类模板。这意味着：
    生成一个具体的类类型 MyClass。
    实例化该类所有非模板、非虚的成员变量声明​（类型确定）。
    ​但不会立即实例化所有成员函数的定义体！​​ 这是关键。
    ​成员函数调用：​​ 当你调用一个类模板实例的成员函数时（如 obj.doSomething(42);），过程与函数模板调用类似：
    ​名称查找：​​ 在 MyClass的作用域内查找 doSomething的声明（包括普通成员函数、成员函数模板、从基类继承的成员等）。
    ​重载解析：​​ 对找到的候选（包括成员函数模板推导出的签名）进行匹配，选择最佳匹配。
    ​实例化：​​ ​只有当选中的成员函数是一个模板，或者它属于一个尚未完全实例化的类模板时，编译器才会在需要时实例化该特定成员函数的定义体。这就是 ​​“惰性实例化” (Lazy Instantiation)​​ 原则：只实例化真正被用到的成员函数。

  2. 构造函数的重载解析：​​
    构造函数的调用（如 MyClass obj(42);）是类模板成员函数调用的一个特例，也是最常见的场景。
    过程完全遵循上述成员函数调用的规则：
    名称查找：在 MyClass中查找构造函数声明。
    重载解析：将实参 42(int) 与所有候选构造函数（包括构造函数模板推导出的签名）进行匹配，选择最佳匹配（如 MyClass::MyClass(int)）。
    实例化：如果选中的构造函数是模板或者尚未实例化，则实例化它的定义体。
    ​过程是否一样？​​
    ​核心机制相同：​​ 成员函数（包括构造函数）的重载解析过程​（名称查找、生成候选集、参数匹配、选择最佳）与普通函数和函数模板的机制在逻辑上是一致的。都涉及模板参数推导（如果是模板成员函数）和转换序列比较。
    ​作用域不同：​​ 名称查找发生在类作用域​（MyClass::）内，而不是全局或命名空间作用域。
    ​实例化触发点：​​ 类模板的实例化（生成类类型）是成员函数调用的前提。成员函数的实例化发生在类实例化之后，并且是按需（惰性）进行的。
    ​特殊成员：​​ 类模板的友元函数可能涉及 ADL，规则更复杂一些。

​总结（类模板）：​​

类模板本身的实例化（MyClass）会生成一个具体的类类型。
对该类实例的成员函数的调用​（包括构造函数），会触发一个与函数模板调用非常相似的重载解析和按需实例化过程。
核心区别在于作用域（类作用域）和实例化的层次（先实例化类，再按需实例化成员函数）。

模板的特化

概念： 通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{return left < right;
}
int main()
{cout << Less(1, 2) << endl; // 可以比较，结果正确Date d1(2022, 7, 7);Date d2(2022, 7, 8);cout << Less(d1, d2) << endl; // 可以比较，结果正确，内部会调用Date类的operate<赋值重载函数.Date* p1 = &d1;Date* p2 = &d2;cout << Less(p1, p2) << endl; // 可以比较，结果错误，指针之间的比较没有意义，要正确比较的逻辑，我们就需要对该模板特化一下.return 0;
}

可以看到，Less绝对多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。

此时，就需要对模板进行特化。

模板的特化: 在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

3. 函数模板特化

函数模板的特化步骤：

  1. 必须要先有一个基础的函数模板
  2. 关键字template后面接一对空的尖括号<>
  3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
  4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{return left < right;
}
// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
{return *left < *right;
}
int main()
{cout << Less(1, 2) << endl;Date d1(2022, 7, 7);Date d2(2022, 7, 8);cout << Less(d1, d2) << endl;Date* p1 = &d1;Date* p2 = &d2;cout << Less(p1, p2) << endl; // 调用特化之后的版本，而不走模板生成了return 0;
}

注意：一般情况下如果函数模板遇到模板特化比较复杂，类型不能处理或者处理有误的情况，通常直接将该函数给出更加简单方便。

bool Less(Date* left, Date* right)
{return *left < *right;
}

4. 类模板特化

类模板只可以使用显示的传类型实例化，不可以隐式的推导类型，因为我们调用构造函数传参的过程，不一定会传入类型。

4.1 全特化

全特化即是将模板参数列表中所有的参数都确定化。

template<class T1, class T2>
class Data
{
public:Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};
template<>
class Data<int, char>
{
public:Data() { cout << "Data<int, char>" << endl; }
private:int _d1;char _d2;
};
void TestVector()
{Data<int, int> d1;Data<int, char> d2;
}

4.2 偏特化

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。偏特化可以从两个方面。

比如对于以下模板类：

template<class T1, class T2>
class Data
{
public:Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};//(1). 将模板参数类表中的一部分参数特化：
// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:Data() { cout << "Data<T1, int>" << endl; }
private:T1 _d1;int _d2;
};//(2). 参数更进一步的限制：
//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:Data() { cout << "Data<T1*, T2*>" << endl; }private:T1 _d1;T2 _d2;
};
//两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data <T1&, T2&>
{
public:Data(const T1& d1, const T2& d2): _d1(d1), _d2(d2){cout << "Data<T1&, T2&>" << endl;}private:const T1& _d1;const T2& _d2;
};
void test2()
{Data<int, double> d2; // 调用基础的模板 Data<double, int> d1; // 调用特化的int版本Data<int*, int*> d3; // 调用特化的指针版本Data<int&, int&> d4(1, 2); // 调用特化的指针版本
}

类模板的偏特化，可以从两个方面：

  1. 将模板参数类表中的一部分参数特化
  2. 参数更进一步的限制

4.3 类模板特化应用示例

有如下专门用来按照小于比较的类模板Less，使用重载operate()实现像使用函数一样使用该类：

#include<vector>
#include <algorithm>
using namespace std;
template<class T>
struct Less
{bool operator()(const T& x, const T& y) const{return x < y;}
};int main()
{Date d1(2022, 7, 7);Date d2(2022, 7, 6);Date d3(2022, 7, 8);vector<Date> v1;v1.push_back(d1);v1.push_back(d2);v1.push_back(d3);// 可以直接排序，结果是日期升序sort(v1.begin(), v1.end(), Less<Date>());vector<Date*> v2;v2.push_back(&d1);v2.push_back(&d2);v2.push_back(&d3);// 可以直接排序，结果错误日期还不是升序，而v2中放的地址是升序// 此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象// 但是走Less模板，sort在排序时实际比较的是v2中指针的地址，因此无法达到预期sort(v2.begin(), v2.end(), Less<Date*>());return 0;
}

通过观察上述程序的结果发现，对于日期对象可以直接排序，并且结果是正确的。但是如果待排序元素是指针，结果就不一定正确。因为：sort最终按照Less模板中方式比较，所以只会比较指针，而不是比较指针指向空间中内容，此时可以使用类版本特化来处理上述问题：

// 对Less类模板按照指针方式特化
template<>
struct Less<Date*>
{bool operator()(Date* x, Date* y) const{return *x < *y;}
};

特化之后，在运行上述代码，就可以得到正确的结果。

这种通过operate()重载，让类的使用和函数一样的，我们称它为仿函数，仿函数最常用的使用场景是在算法中传入，代替函数指针使排序顺序改变。

为什么函数重载没有偏特化？

  1. 因为函数有函数重载，而类没有，所以函数不需要特化，而类需要。
  2. 如果允许函数模板偏特化，会导致规则冲突：
template <typename T> void foo(T);    // #1 主模板
template <typename T> void foo(T*);   // #2 指针的重载
template <typename T> void foo<int>(T); // #3 伪偏特化（如果允许）foo(42);   // 应匹配#1还是#3？
foo(&x);   // 应匹配#2还是#1的特化？

模板分离编译

5.什么是分离编译

我们知道一个C++程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件，这个过程我们称为分离编译模式。

5.1 函数模板的分离编译

假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：

// a.h
template<class T>
T Add(const T& left, const T& right);
// a.cpp
template<class T>
T Add(const T& left, const T& right)
{return left + right;
}
// main.cpp
#include"a.h"
int main()
{Add(1, 2);Add(1.0, 2.0);return 0;
}

在这里插入图片描述
解决方法：

  1. 模板的定义直接放在头文件中 “xxx.hpp” 或者"xxx.h"里面，这样在包含头文件的地方，编译器就能看到完整的定义，从而在需要时实例化模板。（推荐这种做法）
// a.h
template<class T>
T Add(const T& left, const T& right)
{return left + right;
}// main.cpp
#include"a.h"
int main()
{Add(1, 2);Add(1.0, 2.0);return 0;
}
  1. 模板定义的位置显式实例化，这样编译器会针对a.cpp中的显示实例化，生成对应类型的普通函数实体，这样就可以像普通的函数一样，具有外部连接属性，在最后被main.cpp链接的时候找到并使用。
// a.h
template<class T>
T Add(const T& left, const T& right);// a.cpp
template<class T>
T Add(const T& left, const T& right)
{return left + right;
}
template int Add<int>(const int&, const int&);
template double Add<double>(const double&, const double&);
template float Add<float>(const float&, const float&);// main.cpp
#include"a.h"
int main()
{Add(1, 2);Add(1.0, 2.0);return 0;
}

推荐第一种做法，因为第一种做法可以最大限度的发挥我们使用模板的优势，第二种方式有点华而不实了。

5.2 类模板的分离编译

类模板的分离编译和函数模板类似。

非类型模板参数

模板参数分类类型形参与非类型形参。
类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

// 定义一个模板类型的静态数组
template<class T, size_t N = 10>
class array
{
public:T& operator[](size_t index) { return _array[index]; }const T& operator[](size_t index)const { return _array[index]; }size_t size()const { return _size; }bool empty()const { return 0 == _size; }private:T _array[N];size_t _size;
};

注意：

  1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。

模板优缺

【优点】

  1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
  2. 增强了代码的灵活性
    【缺陷】
  3. 模板会导致代码膨胀问题，也会导致编译时间变长
  4. 出现模板编译错误时，错误信息非常凌乱，不易定位错误

总结

  1. 泛型编程在C++中就是模板，是一种代码复用、代码可维护性的手段，它会根据传入的参数自动的推导类型。
  2. 函数模板可以隐式实例化和显示传入参数的实例化。
  3. 函数模板的匹配原则在C++编译器自动查找函数调用的前提下，根据推导出的模板参数（如 double或 char）去实例化该模板的完整定义​（函数体代码）。
  4. 类模板的匹配原则在整体类型的实例化上和函数的过程相似，但是其内部模板成员函数的调用，也依旧遵循模板函数的匹配原则，即作用域中查找和按需求实例化，没有使用到的模板成员变量和模板成员函数是不会被实例化的。
  5. 模板我们可以提前按照一些特殊情况写出一些特殊的模板，让编译器在查找的过程中根据优先匹配原则，优先匹配到，特殊的去实例化，即模板的特化。
  6. 函数模板不可以偏特化，因为已经有函数重载了。
  7. 类模板可以偏特化，因为它没有重载。
  8. 类模板的特化可以分为针对部分参数的类型指定和对参数的进一步限制。
  9. 模板的分离编译会导致编译器扫描不到不同编译单元之间的模板定义，从而无法根据定义生成最终的代码，从而找不到类、函数的定义，从而报错。
  10. 非类型

本文章为作者的笔记和心得记录，顺便进行知识分享，有任何错误请评论指点：）。

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

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

相关文章

【基于YOLO和Web的交通工具识别系统】

【基于YOLO和Web的交通工具识别系统】

系统功能 视频检测&#xff1a;对输入的视频流进行实时或离线分析&#xff0c;自动识别视频中出现的交通工具&#xff08;如飞机、自行车等&#xff09;及行人&#xff0c;输出包含目标类别、位置等信息的检测结果。摄像检测&#xff1a;通过连接摄像头设备&#xff0c;对实时…
阅读更多...
Python进程，线程

Python进程，线程

目录 一、多任务 1.1定义 1.2具体体现 1.3并发和并行 1.3.1并发操作 1.3.2并行操作 1.3.3对比 二、进程 2.1概念 2.2特点 2.3进程状态 2.4多进程 2.5多进程实现 2.6进程锁 三、线程 3.1概念 3.2特点 3.3适用场景 3.4多线程实现 四、对比 4.1关系对⽐ 4.2区…
阅读更多...
【Element Plus 表单组件样式统一 CSS 文字特效实现指南】

【Element Plus 表单组件样式统一 CSS 文字特效实现指南】

Element Plus 表单组件样式统一 & CSS 文字特效实现指南 前言 在使用 Element Plus 组件库开发表单页面时&#xff0c;我们遇到了一个看似简单却很有趣的问题&#xff1a;el-input、el-select 和 el-textarea 在禁用状态下的文字颜色不一致。通过深入研究&#xff0c;我们…
阅读更多...
网络通信与协议栈 -- OSI，TCP/IP模型，协议族，UDP编程

网络通信与协议栈 -- OSI，TCP/IP模型，协议族，UDP编程

网络通信的核心是实现不同主机上进程间的数据交换&#xff0c;其技术体系围绕 “协议分层模型” 展开&#xff0c;向下依赖硬件介质传输电 / 光信号&#xff0c;向上支撑各类网络应用&#xff08;如网页浏览、文件传输&#xff09;。本文结合 OSI 理论框架与 TCP/IP 工业标准&a…
阅读更多...
HarmonyOS 新一代声明式 UI 弹窗机制：从 AlertDialog 到 CustomDialogController 的深度解析与实践

HarmonyOS 新一代声明式 UI 弹窗机制：从 AlertDialog 到 CustomDialogController 的深度解析与实践

好的&#xff0c;请看这篇关于 HarmonyOS 新一代声明式 UI 弹窗机制的技术文章。 HarmonyOS 新一代声明式 UI 弹窗机制&#xff1a;从 AlertDialog 到 CustomDialogController 的深度解析与实践 引言 在 HarmonyOS 应用开发中&#xff0c;弹窗&#xff08;Dialog&#xff09;是…
阅读更多...
混合推理模型(快思考、慢思考模型)

混合推理模型(快思考、慢思考模型)

目录基础transformer架构、transformers库预训练模型的微调&#xff08;Fine-tuning&#xff09;预训练微调的大模型应用模式base 模型、instruct 模型区别Hugging Face 上如何查看base模型、instruct模型混合推理模型大模型里的快思考 vs 慢思考qwen3模型含特殊 ChatML / 模型…
阅读更多...
prometheus+grafana搭建

prometheus+grafana搭建

部署 prometheus 安装 # 1,下载 wget https://github.com/prometheus/prometheus/releases/download/v2.45.1/prometheus-3.5.0.linux-amd64.tar.gz# 2,部署 tar -zxvf prometheus-3.5.0.linux-amd64.tar.gz -C /opt/ cd /opt/ mv ./prometheus-3.5.0.linux-amd64 …
阅读更多...
MR30分布式I/O在面机装备中的应用

MR30分布式I/O在面机装备中的应用

随着食品加工行业向自动化、智能化转型&#xff0c;面机装备对控制系统的响应速度、布线灵活性及稳定性提出了更高要求。本案例以某大型食品机械制造企业的全自动面条生产线升级项目为背景&#xff0c;引入 MR30 分布式 IO 模块替代传统集中式 IO 方案。通过将 MR30 分布式 IO …
阅读更多...
Matlab使用小技巧合集（系列四）：Table类型高效用法与数据处理实战

Matlab使用小技巧合集（系列四）：Table类型高效用法与数据处理实战

Matlab使用小技巧合集（系列四）：Table类型高效用法与数据处理实战 在科研数据处理和论文写作过程中，结构化数据的管理极为重要。Matlab的table类型为研究生和科研人员提供了灵活、高效的数据存储与处理方式，尤其适合实验结果整理、分组统计、数据预处理等场景。本文将系统介…
阅读更多...
STM32的时钟系统与时钟树的配置

STM32的时钟系统与时钟树的配置

STM32的时钟系统是其微控制器&#xff08;MCU&#xff09;的核心组成部分&#xff0c;负责为CPU、外设和存储器等模块提供精确的时序信号。其设计灵活且复杂&#xff0c;通过多级时钟树&#xff08;Clock Tree&#xff09;实现时钟源的选择、分频和分配。以下是详细介绍&#x…
阅读更多...
NV 工具metrics分析（ncu, nsys/torch profiler）

NV 工具metrics分析（ncu, nsys/torch profiler）

以下分析都以A100硬件架构为例; Theoretical Max Active Warps per SM: 64 Register number: 512 (规定每个thread不能超过256) Theoretical Active Warps per SM [warp]&#xff1a;512//registers_per_thread*4, which defines theoretical active warp occupancy Waves P…
阅读更多...
[CISCN2019 总决赛 Day2 Web1]Easyweb

[CISCN2019 总决赛 Day2 Web1]Easyweb

登录界面可以看到随机切换的图片。从页面源码中可以看到<div class"avtar"><img src"image.php?id3" width"200" height"200"/></div>&#xff0c;图片文件的请求地址&#xff0c;并且有传参id。web应用中像这种动…
阅读更多...
第 3 讲：KAFKA生产者（Producer）详解

第 3 讲：KAFKA生产者（Producer）详解

这是一篇既照顾入门也能给高级工程师提供落地经验的实战笔记。0. TL;DR&#xff08;先上结论&#xff09; 想稳&#xff1a;acksall 合理 retries&#xff1b;需要“分区内不重不丢”→ 再加 enable.idempotencetrue 且 max.in.flight<5。想快&#xff1a;适度增大 batch.s…
阅读更多...
微信小程序截屏与录屏功能详解

微信小程序截屏与录屏功能详解

微信小程序提供了丰富的API支持截屏和录屏功能&#xff0c;适用于多种场景&#xff0c;如教育类应用的课程录制、游戏类应用的精彩瞬间分享、电商类应用的商品展示等。以下将详细介绍实现方法和应用案例。 截屏功能实现 截屏功能通过调用wx.canvasToTempFilePath或wx.captureSc…
阅读更多...
React 中的 HOC 和 Hooks

React 中的 HOC 和 Hooks

写在前面 在函数式组件主导的 React 项目中&#xff0c;高阶组件&#xff08;HOC&#xff09;并非首选推荐&#xff0c;更建议优先使用 Hooks来实现复用逻辑。核心原因是 HOC 存在固有的设计缺陷&#xff0c;而 Hooks 能更优雅、简洁地解决相同问题&#xff0c;同时避免 HOC 的…
阅读更多...
【 苍穹外卖 | Day2】

【 苍穹外卖 | Day2】

1. 相关视频 Day2的全部视频集数 2. 学习记录 2.1 对象属性拷贝 当DTO与实体类或者VO对象之间的一个装换的时候&#xff0c;如果通过new创建对象&#xff0c;然后调用set方法进行属性赋值&#xff0c;不够方便&#xff0c;代码不够简洁。当属性过多时候&#xff0c;代码就会…
阅读更多...
焊接自动化测试平台图像处理分析-模型训练推理

焊接自动化测试平台图像处理分析-模型训练推理

1、使用技术栈&#xff1a;jdk17/springboot/python/opencv/yolov8 2、JAVA环境搭建 JDK17下载安装&#xff1a;wget https://download.oracle.com/java/17/latest/jdk-17_linux-x64_bin.tar.gz 解压软件 tar -xf jdk-17.0.16_linux-x64_bin.tar.gz 配置全局变量 vim /etc/p…
阅读更多...
【python实用小脚本-205】[HR揭秘]手工党逐行查Bug的终结者｜Python版代码质量“CT机”加速器（建议收藏）

【python实用小脚本-205】[HR揭秘]手工党逐行查Bug的终结者｜Python版代码质量“CT机”加速器（建议收藏）

1. 场景故事 “作为HR&#xff0c;我曾用2小时逐行审阅50份Python简历项目&#xff0c;直到发现候选人的代码复杂度超标导致线上事故…” → 转折点&#xff1a;用麦凯布&#xff08;McCabe&#xff09;圈复杂度检测脚本&#xff0c;30秒扫描全仓库&#xff0c;现可100%拦截“高…
阅读更多...
LeetCode - 1089. 复写零

LeetCode - 1089. 复写零

题目 1089. 复写零 - 力扣&#xff08;LeetCode&#xff09; 思路 这道题我首先想到的是从前往后双指针&#xff0c;但是这样做会造成数据的覆盖&#xff0c;比如说下面的这个情况 所以解决的方法就是从后往前去复写&#xff0c;但是从后往前的话就要知道最后一个有效元素是…
阅读更多...
c#中public类比博图

c#中public类比博图

简单来说&#xff0c;**public 定义了“接口”或“引脚”**&#xff0c;就像你的FB块上的 Input, Output, InOut 管脚一样。它决定了外部的其他代码&#xff08;如另一个FB或OB1&#xff09;可以看到和操作这个块里的什么东西。让我用你最熟悉的博图概念来详细类比一下。---###…
阅读更多...
最新文章

Copyright @ 2022~2023