C++中的模板

模板概论

        c++提供了函数模板 (function template.) 所谓函数模板，实际上是建立一个通用函 数，其函数类型和形参类型不具体制定，用一个虚拟的类型来代表。这个通用函数 就成为函数模板。凡是函数体相同的函数都可以用这个模板代替，不必定义多个函 数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板 中的虚拟类型，从而实现不同函数的功能。
c++ 提供两种模板机制 :
        函数模板和类模板
        类属 - 类型参数化，又称参数模板
总结：
        模板把函数或类要处理的数据类型参数化，表现为参数的多态性，成为类属。
        模板用于表达逻辑结构相同，但具体数据元素类型不同的数据对象的通用行为。

函数模板

//交换 int 数据
void SwapInt(int& a,int& b){
    int temp = a;
    a = b;
    b = temp;
}
//交换 char 数据
void SwapChar(char& a,char& b){
    char temp = a;
    a = b;
    b = temp;
}
//问题：如果我要交换 double 类型数据，那么还需要些一个 double 类型数据交换的函
数
//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中
增加了代码的维护难度
//如果能把类型作为参数传递进来就好了，传递 int 就是 Int 类型交换，传递 char 就是
    char 类型交换
//我们有一种技术，可以实现类型的参数化---函数模板
//class 和 typename 都是一样的，用哪个都可以
template<class T>
void MySwap(T& a,T& b){
    T temp = a;
    a = b;
    b = temp;
}
void test01(){
    int a = 10;
    int b = 20;
    cout << "a:" << a << " b:" << b << endl;
    //1. 这里有个需要注意点，函数模板可以自动推导参数的类型
    MySwap(a,b);
    cout << "a:" << a << " b:" << b << endl;
    char c1 = 'a';
    char c2 = 'b';
    cout << "c1:" << c1 << " c2:" << c2 << endl;
    //2. 函数模板可以自动类型推导，那么也可以显式指定类型
    MySwap<char>(c1, c2);
    cout << "c1:" << c1 << " c2:" << c2 << endl;
}
用模板是为了实现泛型，可以减轻编程的工作量，增强函数的重用性。

函数模板和普通函数区别

函数模板不允许自动类型转化
普通函数能够自动进行类型转化 
//函数模板
template<class T>
T MyPlus(T a, T b){
    T ret = a + b;
    return ret;
}
//普通函数
int MyPlus(int a,char b){
    int ret = a + b;
    return ret;
}
void test02(){
    int a = 10;
    char b = 'a';
    //调用函数模板，严格匹配类型
    MyPlus(a, a);
    MyPlus(b, b);
    //调用普通函数
    MyPlus(a, b);
    //调用普通函数 普通函数可以隐式类型转换
    MyPlus(b, a);
    //结论：
    //函数模板不允许自动类型转换，必须严格匹配类型
    //普通函数可以进行自动类型转换
}

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

c++ 编译器优先考虑普通函数
可以通过空模板实参列表的语法限定编译器只能通过模板匹配
函数模板可以像普通函数那样可以被重载
如果函数模板可以产生一个更好的匹配，那么选择模板 
//函数模板
template<class T>
T MyPlus(T a, T b){
    T ret = a + b;
    return ret;
}
//普通函数
int MyPlus(int a, int b){
    int ret = a + b;
    return ret;
}
void test03(){
    int a = 10;
    int b = 20;
    char c = 'a';
    char d = 'b';
    //如果函数模板和普通函数都能匹配，c++编译器优先考虑普通函数
    cout << MyPlus(a, b) << endl;
    //如果我必须要调用函数模板,那么怎么办?
    cout << MyPlus<>(a, b) << endl;
    //此时普通函数也可以匹配，因为普通函数可以自动类型转换
    //但是此时函数模板能够有更好的匹配
    //如果函数模板可以产生一个更好的匹配，那么选择模板
    cout << MyPlus(c,d);
}
//函数模板重载
template<class T>
T MyPlus(T a, T b, T c){
    T ret = a + b + c;
    return ret;
}
void test04(){
    int a = 10;
    int b = 20;
    int c = 30;
    cout << MyPlus(a, b, c) << endl;
    //如果函数模板和普通函数都能匹配，c++编译器优先考虑普通函数
}

模板机制剖析

思考 :   为什么函数模板可以和普通函数放在一起 ?c++ 编译器是如何实现函数模板机 制的？

编译过程

        hello.cpp 程序是高级 c 语言程序，这种程序易于被人读懂。为了在系统上运行 hello.c 程序，每一条 c 语句都必须转化为低级的机器指令。然后将这些机器指令 打包成可执行目标文件格式，并以二进制形式存储于磁盘中。
        预处理(Pre-processing) -> 编译 (Compiling) -> 汇编 (Assembling) -> 链接 (Linking)

模板实现机制

函数模板机制结论：
        编译器并不是把函数模板处理成能够处理任何类型的函数
        函数模板通过具体类型产生不同的函数
        编译器会对函数模板进行两次编译，在声明的地方对模板代码本身进行编译，在 调用的地方对参数替换后的 代码进行编译。

模板的局限性

假设有如下模板函数：
                template < class T>
                void f(T a, T b)
                { … }
        如果代码实现时定义了赋值操作 a = b ，但是 T 为数组，这种假设就不成立了 同样，如果里面的语句为判断语句 if(a>b), 但 T 如果是结构体，该假设也不成立， 另外如果是传入的数组，数组名为地址，因此它比较的是地址，而这也不是我们所 希望的操作。
        总之，编写的模板函数很可能无法处理某些类型，另一方面，有时候通用化是有 意义的，但 C++ 语法不允许这样做。为了解决这种问题，可以提供模板的重载，为这些特定的类型提供具体化的模板。 
class Person
{
public:
    Person(string name, int age)
    {
        this->mName = name;
        this->mAge = age;
    }
    string mName;
    int mAge;
};
//普通交换函数
template <class T>
void mySwap(T &a,T &b)
{
    T temp = a;
    a = b; 
    b = temp;
}
//第三代具体化，显示具体化的原型和定意思以 template<>开头，并通过名称来指出类
型
//具体化优先于常规模板
template<>void mySwap<Person>(Person &p1, Person &p2)
{
    string nameTemp;
    int ageTemp;
    nameTemp = p1.mName;
    p1.mName = p2.mName;
    p2.mName = nameTemp;
    ageTemp = p1.mAge;
    p1.mAge = p2.mAge;
    p2.mAge = ageTemp;
}
void test()
{
    Person P1("Tom", 10);
    Person P2("Jerry", 20);
    cout << "P1 Name = " << P1.mName << " P1 Age = " << P1.mAge << endl;
    cout << "P2 Name = " << P2.mName << " P2 Age = " << P2.mAge << endl;
    mySwap(P1, P2);
    cout << "P1 Name = " << P1.mName << " P1 Age = " << P1.mAge << endl;
    cout << "P2 Name = " << P2.mName << " P2 Age = " << P2.mAge << endl;
}

类模板

类模板基本概念

        类模板和函数模板的定义和使用类似，我们已经进行了介绍。有时，有两个或多个 类，其功能是相同的，仅仅是数据类型不同。
        类模板用于实现类所需数据的类型参数化 
template<class NameType, class AgeType>
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->mName = name;
        this->mAge = age;
    }
    void showPerson()
    {
        cout << "name: " << this->mName << " age: " << this->mAge    << endl;
    }
public:
    NameType mName;
    AgeType mAge;
};
void test01()
{
    //Person P1("德玛西亚",18); // 类模板不能进行类型自动推导
    Person<string, int>P1("德玛西亚", 18);
    P1.showPerson();
}

类模板做函数参数

//类模板
template<class NameType, class AgeType>
class Person{
public:
    Person(NameType name, AgeType age){
        this->mName = name;
        this->mAge = age;
    }
void PrintPerson(){
        cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
}
public:
    NameType mName;
    AgeType mAge;
};
//类模板做函数参数
void DoBussiness(Person<string,int>& p){
    p.mAge += 20;
    p.mName += "_vip";
    p.PrintPerson();
}
int main(){
    Person<string, int> p("John", 30);
    DoBussiness(p);
    system("pause");
    return EXIT_SUCCESS;
}

类模板派生普通类 

//类模板
template<class T>
class MyClass{
public:
    MyClass(T property){
        this->mProperty = property;
    }
public:
    T mProperty;
};
//子类实例化的时候需要具体化的父类，子类需要知道父类的具体类型是什么样的
//这样 c++编译器才能知道给子类分配多少内存
//普通派生类
class SubClass : public MyClass<int>{
public:
    SubClass(int b) : MyClass<int>(20){
        this->mB = b;
    }
public:
    int mB;
};
1.7.4 类模板派生类模板
//父类类模板
template<class T>
class Base
{
    T m;
};
template<class T >
class Child2 : public Base<double> //继承类模板的时候，必须要确定基类的大小
{
public:
    T mParam;
};
void test02()
{
    Child2<int> d2;
}

类模板类内实现 

template<class NameType, class AgeType>
class Person
{
public:
    Person(NameType name, AgeType age)
    {
        this->mName = name;
        this->mAge = age;
    }
    void showPerson()
    {
        cout << "name: " << this->mName << " age: " << this->mAge << endl;
    }
public:
    NameType mName;
    AgeType mAge;
};
void test01()
{
    //Person P1("德玛西亚",18); // 类模板不能进行类型自动推导
    Person<string, int>P1("德玛西亚", 18);
    P1.showPerson();
}

类模板类外实现 

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
template<class T1, class T2>
class Person{
public:
    Person(T1 name, T2 age);
    void showPerson();
public:
    T1 mName;
    T2 mAge;
};
//类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){
    this->mName = name;
    this->mAge = age;
}
template<class T1, class T2>
    void Person<T1, T2>::showPerson(){
    cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
}
void test()
{
    Person<string, int> p("Obama", 20);
    p.showPerson();
}
int main(){
    test();
    system("pause");
    return EXIT_SUCCESS;
}

类模板头文件和源文件分离问题

Person.hpp

#pragma once
template<class T1,class T2>
class Person{
public:
    Person(T1 name,T2 age);
    void ShowPerson();
public:
    T1 mName;
    T2 mAge;
};
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){
    this->mName = name;
    this->mAge = age;
}
template<class T1, class T2>
void Person<T1, T2>::ShowPerson(){
    cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
}

main.cpp 

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include<string>
#include"Person.hpp"
//模板二次编译
//编译器编译源码 逐个编译单元编译的
int main(){
    Person<string, int> p("Obama", 20);
    p.ShowPerson();
    system("pause");
    return EXIT_SUCCESS;
}
结论 : 案例代码在 qt 编译器顺利通过编译并执行，但是在 Linux 和 vs 编辑器下如 果只包含头文件，那么会报错链接错误，需要包含 cpp 文件，但是如果类模板中 有友元类，那么编译失败！
解决方案 : 类模板的声明和实现放到一个文件中，我们把这个文件命名为 .hpp( 这个 是个约定的规则，并不是标准，必须这么写).
原因：
        类模板需要二次编译，在出现模板的地方编译一次，在调用模板的地方再次编译。
        C++编译规则为独立编译。

模板类碰到友元函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include <string>
template<class T1, class T2> class Person;
//告诉编译器这个函数模板是存在
template<class T1, class T2> void PrintPerson2(Person<T1, T2>& p);
//友元函数在类内实现
template<class T1, class T2>
class Person{
    //1. 友元函数在类内实现
    friend void PrintPerson(Person<T1, T2>& p){
    cout << "Name:" << p.mName << " Age:" << p.mAge << endl;
}
//2.友元函数类外实现
//告诉编译器这个函数模板是存在
friend void PrintPerson2<>(Person<T1, T2>& p);
//3. 类模板碰到友元函数模板
template<class U1, class U2>
friend void PrintPerson(Person<U1, U2>& p);
public:
    Person(T1 name, T2 age){
        this->mName = name;
        this->mAge = age;
    }
    void showPerson(){
        cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
    }
private:
    T1 mName;
    T2 mAge;
};
void test01()
{
    Person <string, int>p("Jerry", 20);
    PrintPerson(p);
}
// 类模板碰到友元函数
//友元函数类外实现 加上<>空参数列表，告诉编译去匹配函数模板
template<class T1 , class T2>
void PrintPerson2(Person<T1, T2>& p)
{
    cout << "Name2:" << p.mName << " Age2:" << p.mAge << endl;
}
void test02()
{
    Person <string, int>p("Jerry", 20);
    PrintPerson2(p); //不写可以编译通过，写了之后，会找 PrintPerson2 的普通函数调用，因为写了普通函数 PrintPerson2 的声明
}
int main(){
    //test01();
    test02();
    system("pause");
    return EXIT_SUCCESS;
}

类模板的应用

设计一个数组模板类 (MyArray), 完成对不同类型元素的管理 
#pragma once
template<class T>
class MyArray
{
public:
    explicit MyArray(int capacity)
    {
        this->m_Capacity = capacity;
        this->m_Size = 0;
        // 如果 T 是对象，那么这个对象必须提供默认的构造函数
        pAddress = new T[this->m_Capacity];
    }
    //拷贝构造
    MyArray(const MyArray & arr)
    {
        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;
        this->pAddress = new T[this->m_Capacity];
        for (int i = 0; i < this->m_Size;i++)
        {
            this->pAddress[i] = arr.pAddress[i];
        }
    }
    //重载[] 操作符 arr[0]
    T& operator [](int index)
    {
        return this->pAddress[index]; 
    }
    //尾插法
    void Push_back(const T & val)
    {
        if (this->m_Capacity == this->m_Size)
        {
            return;
        }
        this->pAddress[this->m_Size] = val;
        this->m_Size++;
    }
    void Pop_back()
    {
        if (this->m_Size == 0)
        {
            return;
        }
        this->m_Size--;
    }
    int getSize()
    {
        return this->m_Size;
    }
    //析构
    ~MyArray()
    {
        if (this->pAddress != NULL)
        {
            delete[] this->pAddress;
            this->pAddress = NULL;
            this->m_Capacity = 0;
            this->m_Size = 0;
        }
    }
private:
    T * pAddress; //指向一个堆空间，这个空间存储真正的数据
    int m_Capacity; //容量
    int m_Size; // 大小
};
测试代码： 
class Person{
public:
    Person(){}
    Person(string name, int age){
        this->mName = name;
        this->mAge = age;
    }
public:
    string mName;
    int mAge;
};
void PrintMyArrayInt(MyArray<int>& arr){
    for (int i = 0; i < arr.getSize(); i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}
void PrintMyPerson(MyArray<Person>& personArr)
{
    for (int i = 0; i < personArr.getSize(); i++){
        cout << "姓名：" << personArr[i].mName << " 年龄： " << personArr[i].mAge << endl;
    }
}
void test01()
{
    MyArray<int> myArrayInt(10);
    for (int i = 0; i < 9; i++)
    {
        myArrayInt.Push_back(i);
    }
    myArrayInt.Push_back(100);
    PrintMyArrayInt(myArrayInt);
    MyArray<Person> myArrayPerson(10);
    Person p1("德玛西亚", 30);
    Person p2("提莫", 20);
    Person p3("孙悟空",18);
    Person p4("赵信", 15);
    Person p5("赵云", 24);
    myArrayPerson.Push_back(p1);
    myArrayPerson.Push_back(p2);
    myArrayPerson.Push_back(p3);
    myArrayPerson.Push_back(p4);
    myArrayPerson.Push_back(p5);
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

人工智能_AI服务器安装清华开源_CHATGLM大语言模型_GLM-6B安装部署_人工智能工作笔记0092

人工智能_AI服务器安装清华开源_CHATGLM大语言模型_GLM-6B安装部署_人工智能工作笔记0092

看到的这个开源的大模型,很牛,~关键让我们自己也可以部署体验一把了,虽然不知道具体内部怎么构造的但是,也可以自己使用也挺好. 可以部署在自己的机器上也可以部署在云服务器上. 安装以后,是可以使用python代码进行提问,然后返回结果的,这样就可以实现我们自己的chat应用了, …
阅读更多...
TiDB 在咪咕云原生场景下的实践

TiDB 在咪咕云原生场景下的实践

导读 咪咕是中国移动旗下的视频科技公司&#xff0c;门户系统是其核心业务之一。 为满足用户的多样化需求&#xff0c;咪咕计划对其数据库进行升级。 经过对中国主流国产数据库的测试评估后&#xff0c;咪咕选择了 TiDB&#xff0c;并成功将其落地于门户系统云化项目。 TiDB 为…
阅读更多...
太阳能监控智慧杆供电系统

太阳能监控智慧杆供电系统

太阳能监控智慧杆系统工作时无需水、油、汽、燃料&#xff0c;只要有光就能发电的特点&#xff0c;是清洁、无污染的可再生能源&#xff0c;而且安装维护简单&#xff0c;使用寿命长&#xff0c;可以实现无人值守&#xff0c;倍受人们的青睐&#xff0c;是新能源的领头羊。近年…
阅读更多...
【封装UI组件库系列】封装Button图标组件

【封装UI组件库系列】封装Button图标组件

封装UI组件库系列第四篇封装Button按钮组件 &#x1f31f;前言 &#x1f31f;封装Button组件 1.分析封装组件所需支持的属性与事件 支持的属性&#xff1a; 支持的事件&#xff1a; 2.创建Button组件 &#x1f31f;封装功能属性 type主题颜色 plain是否朴素 loading等…
阅读更多...
鸿蒙开发学习——应用程序框架

鸿蒙开发学习——应用程序框架

文章目录 UIAbility的生命周期Create状态WindowStageCreateForeground和Background前后台展示控制onWindowStageDestroyDestory 总结 UIAbility的生命周期 感觉这里他讲的不清晰&#xff0c;UIAbility的4个声明周期是Create、Foreground&#xff08;桌面展示&#xff09;、Back…
阅读更多...
kali linux nmap 端口扫描 简单教程

kali linux nmap 端口扫描 简单教程

本次实验所用工具如下&#xff1a; VMwarekali linux (namp扫描工具)Windows sever 2016 需开启&#xff08;FTP&#xff0c;smp&#xff0c;Telnet&#xff0c;rdp&#xff09;端口namp操作所用部分代码&#xff1a; -sP ping 扫描 -P 指定端口范围 -sV 服务版本探测 -A …
阅读更多...
【UE】绘制抛物线并投射物体

【UE】绘制抛物线并投射物体

效果 步骤 1. 先新建父类为Actor的蓝图&#xff0c;这里命名为“BP_发射物” 打开“BP_发射物”&#xff0c;添加一个球形的静态网格体和一个发射物移动组件 2. 新建一个父类为角色的蓝图&#xff0c;这里命名为“BP_绘制抛物线” 打开“BP_绘制抛物线” 我们希望可以通过控制…
阅读更多...
2023.11.28-电商平台建设03 - 大数据调优手段

2023.11.28-电商平台建设03 - 大数据调优手段

1.优化手段 1.1分桶表 HIVE的分桶本质上就是MR的分区操作 建表语句: create table 表名(字段 类型,.... ) clustered by(分桶字段) [sorted by (字段 [asc | desc])] into N buckets --- 定义分桶表核心语句 row format...... 分桶的作用 1) 进行数据采样工作 1.1) …
阅读更多...
【古月居《ros入门21讲》学习笔记】14_参数的使用与编程方法

【古月居《ros入门21讲》学习笔记】14_参数的使用与编程方法

目录 说明&#xff1a; 1. 参数模型&#xff08;全局字典&#xff09; 2. 实现过程&#xff08;C&#xff09; 创建功能包 参数命令行的使用 YAML参数文件 rosparam命令 使用示例 编程方法&#xff08;C&#xff09; 配置代码编译规则 编译并运行 编译 运行 3. 实…
阅读更多...
五丶openlayer之LOD和分辨率

五丶openlayer之LOD和分辨率

LOD是Levels of Detail的简写&#xff0c;用于根据当前的环境&#xff0c;渲染不同的图像&#xff0c;用于降低非重要的细节度&#xff0c;从而提高渲染效率&#xff0c;在电子游戏中经常运用&#xff0c;对于需要显示全球地图的GIS系统而言&#xff0c;更需要应用这项技术。 …
阅读更多...
Docker+Anaconda+CUDA+cuDNN

Docker+Anaconda+CUDA+cuDNN

一、导语 因为要复现文献的需求和实验室里师兄想要给我提升能力的多方面因素在一起&#xff0c;所以学习并实现了相关安装。在这里做一个记录&#xff0c;方便日后查看&#xff0c;如果能给其他同学带来便捷就更好了。 在这篇文章中&#xff0c;我的目标是搭建一个可以使用Py…
阅读更多...
VSCode Vue 开发环境配置

VSCode Vue 开发环境配置

Vue是前端开发中的重要工具与框架&#xff0c;可以保住开发者高效构建用户界面。 Vue2官方文档&#xff1a;https://v2.cn.vuejs.org/ Vue3官方文档&#xff1a;https://cn.vuejs.org/ Vue的安装和引用 Vue2的官方安装指南&#xff1a;https://v2.cn.vuejs.org/v2/guide/ins…
阅读更多...
github新建项目

github新建项目

参考链接&#xff1a;Github上建立新项目超详细方法过程 在这里新建一个repositories 接下来就选择相关的信息&#xff1a; 然后create a new就行了 接下来需要创建文件&#xff1a;&#xff08;同时通过upload上传文件&#xff09; 每次最多上传100个文件&#xff0c;然后保…
阅读更多...
WEB渗透—反序列化（八）

WEB渗透—反序列化（八）

Web渗透—反序列化 课程学习分享&#xff08;课程非本人制作&#xff0c;仅提供学习分享&#xff09; 靶场下载地址&#xff1a;GitHub - mcc0624/php_ser_Class: php反序列化靶场课程&#xff0c;基于课程制作的靶场 课程地址&#xff1a;PHP反序列化漏洞学习_哔哩哔_…
阅读更多...
11.27二叉查找树，遍历二叉树，层序（判断是不是完全二叉树），根据遍历序列重构二叉树，递归输入建树（树的定义，结构体细节，typedef)

11.27二叉查找树，遍历二叉树，层序（判断是不是完全二叉树），根据遍历序列重构二叉树，递归输入建树（树的定义，结构体细节，typedef)

如果left<right&#xff0c;就表明其之间还有元素&#xff0c;即左右指针重合&#xff0c;区间只有一个元素也被包含其中&#xff1b; left<right,就表明递归过程中&#xff0c;只允许区间有两个及以上的元素&#xff0c;不允许区间只有一个元素&#xff0c;那么对应地&…
阅读更多...
【前端】浅谈async/await异步传染性

【前端】浅谈async/await异步传染性

文章目录 概述观点无法解决可以解决 来源 概述 "异步传染性"问题通常是指&#xff0c;当一个函数使用了async和await&#xff0c;其调用者也需要使用async和await处理异步操作&#xff0c;导致整个调用链都变成异步的。这种情况可能导致代码变得更复杂&#xff0c;不…
阅读更多...
基于若依的ruoyi-nbcio流程管理系统增加流程节点配置（三）

基于若依的ruoyi-nbcio流程管理系统增加流程节点配置（三）

更多ruoyi-nbcio功能请看演示系统 gitee源代码地址 前后端代码&#xff1a; https://gitee.com/nbacheng/ruoyi-nbcio 演示地址&#xff1a;RuoYi-Nbcio后台管理系统 这一节主要是对每个流程节点的字段规则设置与操作规则设置&#xff0c;目前也是只针对自定义业务表单。 1、…
阅读更多...
基于SSM的社区团购系统设计与实现

基于SSM的社区团购系统设计与实现

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;Vue 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#xff1a;是 目录…
阅读更多...
python基于YOLOv8全系列模型【n/s/m/l/x】开发构建不同参数量级的钢铁产业产品智能自动化检测识别系统

python基于YOLOv8全系列模型【n/s/m/l/x】开发构建不同参数量级的钢铁产业产品智能自动化检测识别系统

在前文的项目开发实践中&#xff0c;我们已经以钢铁产业产品缺陷检测数据场景为基准&#xff0c;陆续开发构建了多款目标检测模型&#xff0c;感兴趣的话可以自行阅读即可。 《YOLOv3老矣尚能战否&#xff1f;基于YOLOv3开发构建建钢铁产业产品智能自动化检测识别系统&#xf…
阅读更多...
智能优化算法应用：基于人工蜂群算法无线传感器网络(WSN)覆盖优化 - 附代码

智能优化算法应用：基于人工蜂群算法无线传感器网络(WSN)覆盖优化 - 附代码

智能优化算法应用&#xff1a;基于人工蜂群算法无线传感器网络(WSN)覆盖优化 - 附代码 文章目录 智能优化算法应用&#xff1a;基于人工蜂群算法无线传感器网络(WSN)覆盖优化 - 附代码1.无线传感网络节点模型2.覆盖数学模型及分析3.人工蜂群算法4.实验参数设定5.算法结果6.参考…
阅读更多...
最新文章

Copyright @ 2022~2023