【C++】Cplusplus进阶

news2025/5/10 7:10:57

模板的进阶：

非类型模板参数

        是C++模板中允许使用具体值（而非类型）作为模板参数的特性。它们必须是编译时常量，且类型仅限于整型、枚举、指针、引用。（char也行）

        STL标准库里面也使用了非类型的模板参数。

// 非类型模板参数示例：固定大小的数组
template <typename T, int Size>
class FixedArray 
{
private:
    T data[Size];
public:
    T& operator[](int index) 
    {
        return data[index];
    }

    constexpr int getSize() const 
    { 
        return Size; 
    }
};

int main() {
    FixedArray<int, 5> arr;  // Size=5在编译时确定
    arr[2] = 42;
    static_assert(arr.getSize() == 5);
}

        在 C++ 标准中，非类型模板参数不能直接使用 std::string，但可以使用字符数组或字符指针的形式间接实现类似效果。

template<const char* str>
struct MyTemplate { /* ... */ };

// 定义外部链接的字符数组（C++17 起可用）
extern const char my_str[] = "Hello";
MyTemplate<my_str> obj; // 合法

模板特化

        是C++中针对特定类型或条件提供定制化模板实现的技术，就是模板的特殊化处理，特化不能单独存在。它分为全特化和偏特化，两种形式。

        这里最后一次比较，其实变成了指针与指针比较，比较的是地址的大小。那么这里如果要让指针里面的数据进行比较，那么就要用到模板的特化。

template<class T>
bool Greater(T left, T right)
{
    return left > right;
}

template<>
bool Greater<Date*>(Date* left,Date* right)
{
    return *left > *right;
}

        这样走Date* 比较的时候，就会走第二个模板函数。

        除了函数能特化，类也可以特化。

template<class T>
struct Less
{
    bool operator()(const T& x1,const T& x2) const
    {
        return x1 < x2;
    }
};

template<>
struct Less<Date*>
{
    bool operator()(Date* x1,Date * x2) const 
    {
        return *x1 < *x2;
    }
};

        上面仿函数也可以使用class，但是要注意在public下面操作，不然调不到函数。

        

        这里使用STL库里面的优先级队列，用自己写的模板特化，发现也是可以使用的。

偏特化

        允许为模板参数的一部分或特定条件提供特殊实现。它适用于类模板，但不支持函数模板。

// 通用模板
template <class T, class U>
class MyClass 
{
public:
    void print() {  cout << "General template\n"; }
};

// 偏特化：当第二个参数为 int 时
template <class T>
class MyClass<T, int> 
{
public:
    void print() { cout << "Partial specialization (U = int)\n"; }
};

// 偏特化：当两个参数均为指针类型时
template <class T, class U>
class MyClass<T*, U*> 
{
public:
    void print() { cout << "Partial specialization (both pointers)\n"; }
};

// 使用示例
int main() 
{
    MyClass<double, char> a;      // 通用模板
    MyClass<float, int> b;        // 偏特化（U = int）
    MyClass<int*, double*> c;     // 偏特化（指针类型）
    a.print();  // 输出: General template
    b.print();  // 输出: Partial specialization (U = int)
    c.print();  // 输出: Partial specialization (both pointers)
}
template <class T, class U>
class MyClass<T&, U&> 
{
public:
    void print() { cout << " T& , U& \n"; }
};

模板不支持分离编译

        声明（.h），定义（.cpp）分离。

 PS：模板在同一文件下可以类外定义。

        在类模板中使用typename关键字加在内嵌类型（iterator）前是为了告诉编译器该名称是一个类型，而非静态成员或变量。这种情况发生在模板参数未实例化时，当访问嵌套的依赖类型时，必须使用typename消除歧义。

        zs : : vector<T> : : iterator ，这里要加 typename 。不然编译器区分不清楚这里是类型还是变量。因为静态函数、变量也可以指定类域就可以访问。

        

        这里把push_back() 分开定义后，使用出现链接错误。

        因为构造函数、size()函数、operator[ ]，在vector.h中有定义，所以vector 实例化 v 的时候，这些成员函数同时实例化，直接就有定义。编译阶段直接确定地址。

        而 push_back()、insert()在 vector.h 中只有声明，没有定义。那么只有在链接阶段去确认地址。    

        但是这里 vector.cpp 中模板类型的 T 无法确定，所以没有实例化，就无法进入符号表。进入不了符号表后面链接阶段就会发生错误。

根本原理：

C++标准规定模板是编译期多态机制，编译器需要根据调用处的具体类型生成代码。若模板实现不可见（如分离到.cpp文件），则无法完成实例化。

解决方案：

1.模板声明和定义不要分离到 .h 和 .cpp （推荐）。

2.在cpp 显示实例化。（不推荐，换个类型就要实例化一次，麻烦）

模板总结：

一、优点：

  1. 类型安全：模板在编译期进行类型检查，比宏更安全（如std::vector<int>只能存储int类型）
  2. 代码重用：通过泛型编程减少重复代码（如一个max()模板可处理int/double/string等类型）
  3. 零运行时开销：模板实例化在编译期完成，无额外运行时成本
  4. 高性能泛型算法：STL算法（如sort）能针对不同类型生成优化代码

二、缺点：

  1. 编译错误晦涩：类型不匹配时错误信息冗长（如缺少某个成员函数的错误可能长达数十行）
  2. 编译时间膨胀：每个模板实例化都会生成新代码，大型项目编译时间显著增加
  3. 代码膨胀风险：多个类型实例化可能导致二进制文件增大（如vector<int>和vector<string>会生成两份代码）
  4. 调试困难：调试器难以跟踪模板实例化代码

C++的继承：

        C++继承是面向对象编程的核心机制之一，允许派生类复用基类的属性和方法，同时扩展或修改其行为。

        一个学校里面，人有很多种身份，比如学生、老师、校长、保洁工作人员等。他们有共同的特点也有不同的地方。那么如果对每个人单独的来写一份代码以表明其全部特征，那么代码会非常的冗余。

        因为其作为人这个个体在很多的特征上是相似的，那么使用C++的继承就可以很好的解决这方面的问题。

// 基类：个人
class Person 
{
public:
    string name;
    int age;
    string gender;

    void display() const 
    {
        cout << "姓名: " << name << "\n年龄: " << age
            << "\n性别: " << gender << endl;
    }
};

// 学生类
class Student : public Person 
{
private:
    string studentID;
};

// 教师类
class Teacher : public Person {
private:
    string employeeID;
};

        继承允许一个类（派生类，student，teacher ）基于另一个类（基类，Person ）来创建，从而获得基类的属性和方法，同时可以添加新的特性或覆盖已有的方法。 

        基本语法，派生类通过冒号后跟访问说明符（如public、protected、private）和基类名称来继承基类。

        

        派生类既有基类的属性 （name、age、 gender），也有自己拓展的属性（ studentID、employeeID ）。

代码复用：继承允许派生类直接使用基类的成员（变量和函数），避免重复编写相同逻辑。

层次化建模：通过继承表达现实世界的分类关系（如"动物→哺乳动物→狗"），使代码结构更符合逻辑认知。

继承方式：

        public、protected和private继承。public继承是最常用的，它保持基类成员的访问权限不变。protected继承会将基类的public和protected成员变为派生类的protected成员。private继承则将所有基类成员变为派生类的private成员。这些不同继承方式会影响派生类及其后续派生类对基类成员的访问权限。

        

        其实有规律，直接由权限更小的那个控制。实际上就只有public继承用的比较多。

        protected\priveate：类外不能访问，类里面可以访问。

        不可见：隐身，类里面外面都无法访问。

私有成员的意义：不想被子类继承的成员。

基类中想给子类复用，但是又不想暴露直接访问的成员，就应该定义成保护

class Parent 
{
public:
    string name = "Parent";
};

class Child : public Parent 
{
public:
    string name = "Child";  // 隐藏父类的name

    void printNames() 
    {
        cout << "子类 name: " << name << endl;           // 输出 Child
        cout << "父类 name: " << Parent::name << endl;   // 输出 Parent
    }
};

int main() 
{
    Child obj;
    obj.printNames();
    return 0;
}

 

        当子类和父类都定义了同名成员变量name时，子类会隐藏父类的同名成员。若需访问父类成员，需通过作用域解析运算符显式指明。

1.在继承体系中基类和派生类都有独立的作用域。

2.子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员  显示访问）

         实际上的内存存储中，子类对象包含了基类的数据（name）。.

        若父类的name是private：

        此时子类定义的name是独立的新成员，不会产生命名冲突（但父类成员仍然存在，只是不可直接访问）。

class A
{
public:
    void func()
    {
        cout << "fucn()" << endl;
    }
};

class B : public A
{
public:
    void func(int i)
    {
        cout << "func(int i)->" << endl;
    }
};

        

        有的地方就会提问这里两个 func() 是不是构造函数重载？因为这里是两个不同的类域，所以其构成隐藏。

        当子类对象赋值给父类对象时，会发生对象切片（切割）。这个过程会自动截断子类特有的成员，只保留父类部分。

        子类对象可以赋值给父类对象/指针/引用。这里虽然是不同类型，但是不是隐式类型转换。赋值兼容转换，第三个就能看出来，这里是个特殊支持，语法天然支持。

        子类切割对象赋值给父类，但是不能把父类对象反向赋值给子类对象。

        指针或者引用，其指向父类那一部分的地址或者是那一部分的别名。

继承关系中的默认函数表现：

子类编译器默认生成的 构造函数：

        1、自己的成员，跟类和对象一样。内置类型不处理，自定义类型调用它自己的默认构造。
        2、继承父类成员，必须调用父类的构造函数初始化。

class Person
{
public:
    string _name;
    string _sex;
    int _age;

    Person(const char* name)
        :_name(name)
        ,_sex("男")
        ,_age(10)
    {
        cout << "Person()" << endl;
    }
};

// 学生类
class Student : public Person
{
public:
    int _num;

    Student(const char* name, int num)
        :Person(name)  /*显式调用父类构造函数*/ 
        , _num(num)
    {
        cout << "Studet()" << endl;
    }

};

int main() 
{
    Student s1("张三",001);
    return 0;
}

        注意上面子类再初始化列表里，调用父类的构造函数，初始化继承成员。

子类编译器生成默认生成的 拷贝构造：

1、自己成员，跟类和对象一样。内置类型值拷贝，自定义类型调用它的拷贝构造。
2、继承的父类成员，必须调用父类拷贝构造初始化。

 Person(const Person& p)
     :_name(p._name)
     ,_sex(p._sex)
     ,_age(p._age)
 {
     cout << "Person(const Person& )" << endl;
 }

 Student(const Student& s)
     :Person(s)    /*子类成员拷贝*/
     ,_num(s._num)
 {
     cout << "Studet(const Student& )" << endl;
 }

int main() 
{
    Student s1("张三",001);
    Student st2(s1);
    return 0;
}

 

        这里子类拷贝构造函数（Student(const Student& s)）初始化列表位置，传入基类拷贝构造函数（Person(const Person& p) ）的参数，直接使用了子类对象（s）。这里其实是前面切片的应用。

子类编译器默认生成的 赋值运算符：

1、自己成员，跟类和对象一样。内置类型值拷贝，自定义类型调用它 operator= 的。
2、继承的父类成员，必须调用父类的 operator= 

Person& operator=(const Person& p)
{
    cout << "Person& operator=(const Person& )" << endl;
    _name = p._name;
    _sex = p._sex;
    _age = p._age;
    return *this;
}

Student& operator=(const Student& s)
{
    if (this != &s)
    {
        Person::operator=(s);   // 调用父类赋值
        _num = s._num;
    }
    cout << "Student& operator=(const Student& )" << endl;
    return *this;
}

int main() 
{
    Student s1("张三",001);
    Student st2(s1);
    Student st3("李四",002);
    st2 = st3;
    return 0;
}

 

        这里有个注意的点，调用父类的赋值运算符时要使用类域指定，如果不指定类域，子类默认会去调用自己的赋值运算符，构成死循环。

子类编译器默认生成的 析构函数：

1、自己的成员内置类型不处理，自定义类型调用它的析构函数。
2、继承父类的成员，调用父类析构函数处理。

 ~Person()
{
    cout << "~Person" << endl;
}

~Student()
{
    Person::~Person();
    cout << "~Student() " << endl;
    //...
}

       子类的析构函数跟父类的析构函数构成隐藏。直接调用调不到，要指定类域。  

        

        这里会发现Peson的构造函数调用了三次但是，析构函数调用了六次。这里其实是因为析构函数很特殊。不需要去显示的掉用基类的析构函数，编译器会自己自动的去调用。

~Student()
{
    //Person::~Person();    //不用显示调用
    cout << "~Student() " << endl;
    //...
}

        这是因为其数据存储结构，比如一个子类 （Student），它会先存储父类（Person）的成员，然后在下面存储自己的成员。因为其数据存在栈帧上的，要遵循后进先出规则，所以后构造的先析构（与构造顺序相反，子类数据后构造），先调用派生类的析构函数，再调用基类的析构函数。

        每个子类析构函数后面会自动调用父类析构函数，这样才能保证先析构子类，再析构父类。（自己手写编译器无法保证顺序）

继承和友元：

        PS：友元关系不能被继承。基类的友元不会自动成为派生类的友元。

        如果想访问子类的私有数据，设置为子类的友元就行。

继承中静态成员的作用与访问规则

        静态成员（静态变量、静态方法）属于类本身，而非类的实例。所有实例共享静态成员，且通过类名直接访问。

class Person
{
public:
    Person() { ++_count; }
    string _name;
    static int _count;    //静态成员变量
};

int Person::_count = 0;

class Student : public Person
{
protected:
    int _num;
};

        共享性：父类的静态成员会被子类继承，但子类与父类共享同一份静态成员。

class Parent 
{ 
public:
static int value; 
};

class Child : public Parent 
{ 
public: 
static int value; 
};

Parent::value = 10;  // 父类静态成员
Child::value = 20;   // 子类静态成员（隐藏父类的同名成员）

        隐藏：若子类定义了同名静态成员，父类的静态成员会被隐藏，但未被覆盖（通过父类名仍可访问）。

多继承：

单继承：单继承指一个子类仅能继承一个父类的属性和方法。这是大多数面向对象编程语言的基础特性，能简化代码结构并减少复杂性。

class Animal {
public:
    void eat() { cout << "Eating" << endl; }
};

class Dog : public Animal {
public:
    void bark() { cout << "Barking" << endl; }
};

多继承：多继承允许一个子类同时继承多个父类，增强了代码复用能力，但可能引发命名冲突（如多个父类有同名成员）和复杂性。

class Base1 { public: int a = 100; };
class Base2 { public: int b = 200; };

class Derived : public Base1, public Base2 
{
public:
    int sum() { return a + b; }
};

Q：如何定义一个不能被继承的类？

1.父类构造私有化。子类对象实例化不能调用构造函数。

2. final 关键字 修饰 不能被继承的类。 （C++11）

Q：下面代码 p1、p2、p3的大小关系？

class Base1 { public: int _a; };
class Base2 { public: int _b; };

class Derived : public Base1, public Base2
{
public:
    int _d;
};

int main()
{
    Derived d;
    Base1* p1 = &d;
    Base2* p2 = &d;
    Derived* p3 = &d;
    return 0;
}

A：p1=p3!=p2

        这里其实是看对切割的理解深不深。

        这里p1指向的是base1，p2指向的是base2，都是指向对应数据的开头。p3指向的是整体，指向的是整体数据的首地址。

class Derived : public Base2, public Base1  //先继承 Base2
{
public:
    int _d;
};

PS：子类先继承谁，谁的数据在前面。

        这里数据位置改变，p1、p2指向的位置也会改变。p2=p3!=p1。

Q：这里p1、p2谁的地址大（先继承Base1，再继承Base2）？

        因为数据存储在栈帧中，是先存低地址再存高地址（这里先存的_a、_b、_c）。所以 p2 > p1、p3。

        

         

菱形继承：

        菱形继承是多继承的特殊情况，指一个子类的多个父类继承自同一个基类，导致基类的成员在子类中存在多份副本。

class Person
{
public:
    string _name;
};

class Student : public Person
{
protected:
    int _num;
};

class Teacher :public Person
{

};

class Assistant :public Student, public Teacher
{

};

        当多个父类继承自同一个祖先类时，可能导致成员重复和调用歧义。菱形继承有数据冗余和二义性的问题。在 Assistant 的对象中 Person 成员会有两份。

        指定类域调用就明确了。监视窗口能看到有多份的数据。

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

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

相关文章

透明的卡组收费模式IC++

透明的卡组收费模式IC++

IC是信用卡处理商用来计算每笔交易相关费用的定价模型。与统一或混合定价相比&#xff0c;IC提供了额外的透明度。 作为企业主&#xff0c;了解IC定价的来龙去脉至关重要&#xff0c;以确定它是否对您的运营有意义。 什么是IC&#xff1f; IC或interchange plus是一种流行的定…
阅读更多...
吾爱置顶软件，吊打电脑自带功能！

吾爱置顶软件，吊打电脑自带功能！

今天我给大家带来一款超棒的软件&#xff0c;它来自吾爱论坛的精选推荐&#xff0c;每一款都经过精心挑选&#xff0c;绝对好用&#xff01; S_Clock 桌面计时软件 这款软件的界面设计特别漂亮&#xff0c;简洁又大方。它是一款功能齐全的时钟计时倒计时软件&#xff0c;既能正…
阅读更多...
使用MFC ActiveX开发KingScada控件（OCX）

使用MFC ActiveX开发KingScada控件（OCX）

最近有个需求&#xff0c;要在KingScada上面开发一个控件。 原来是用的WinCC&#xff0c;WinCC本身是支持调用.net控件&#xff0c;就是winform控件的&#xff0c;winform控件开发简单&#xff0c;相对功能也更丰富。奈何WinCC不是国产的。 话说KingScada&#xff0c;国产组态软…
阅读更多...
【AI论文】CodeARC：评估归纳程序合成中大语言模型代理的推理能力基准

【AI论文】CodeARC：评估归纳程序合成中大语言模型代理的推理能力基准

摘要&#xff1a;归纳程序合成&#xff0c;或称示例编程&#xff0c;要求从输入输出示例中合成能够泛化到未见输入的函数。尽管大型语言模型代理在自然语言指导下的编程任务中展现出了潜力&#xff0c;但它们在执行归纳程序合成方面的能力仍待深入探索。现有的评估协议依赖于静…
阅读更多...
加密解密工具箱 - 专业的在线加密解密工具

加密解密工具箱 - 专业的在线加密解密工具

加密解密工具箱 - 专业的在线加密解密工具 您可以通过以下地址访问该工具&#xff1a; https://toolxq.com/static/hub/secret/index.html 工具简介 加密解密工具箱是一个功能强大的在线加密解密工具&#xff0c;支持多种主流加密算法&#xff0c;包括 Base64、AES、RSA、DES…
阅读更多...
抖音短视频安卓版流畅度测评 - 真实

抖音短视频安卓版流畅度测评 - 真实

对于抖音短视频安卓版的流畅度&#xff0c;实际体验可以受到多方面因素的影响&#xff0c;比如设备性能、系统优化、网络情况和应用本身的优化程度。以下是一些常见的测评维度和抖音安卓版本流畅度的实际表现&#xff1a; 1.启动速度 抖音的启动速度通常较快&#xff0c;但如果…
阅读更多...
基于javaweb的SSM+Maven机房管理系统设计与实现(源码+文档+部署讲解）

基于javaweb的SSM+Maven机房管理系统设计与实现(源码+文档+部署讲解）

技术范围&#xff1a;SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、小程序、安卓app、大数据、物联网、机器学习等设计与开发。 主要内容&#xff1a;免费功能设计、开题报告、任务书、中期检查PPT、系统功能实现、代码编写、论文编写和辅导、论文…
阅读更多...
发动机试验台底座：汽车研发的关键支撑(北重制造厂家)

发动机试验台底座：汽车研发的关键支撑(北重制造厂家)

发动机试验台底座是汽车研发过程中的重要组成部分&#xff0c;它承载着发动机及相关部件&#xff0c;在试验过程中提供稳定的支撑。底座的设计和制造对于发动机试验的精度和可靠性至关重要&#xff0c;它需要具备足够的承载能力、稳定性和耐久性&#xff0c;以确保试验过程的准…
阅读更多...
Linux红帽：RHCSA认证知识讲解（九）标准输入输出、重定向、过滤器与管道

Linux红帽：RHCSA认证知识讲解（九）标准输入输出、重定向、过滤器与管道

Linux红帽&#xff1a;RHCSA认证知识讲解&#xff08;九&#xff09;标准输入输出、重定向、过滤器与管道 前言一、标准输入与输出、重定向&#xff0c;使用过滤器筛选文件信息1.1 Linux 的标准输入与输出1.2 什么是输入重定向1.3 输出重定向1.4 标准错误输出重定向1.5 使用过滤…
阅读更多...
智慧园区大屏如何实现全局监测：监测意义、内容、方式

智慧园区大屏如何实现全局监测：监测意义、内容、方式

智慧园区的价值不容小觑呀&#xff0c;可以说园区的大部分数据都在这个大屏上&#xff0c;监测数据越多&#xff0c;那么大屏的价值就越大。很多小伙伴拿到需求后感觉无从下手&#xff0c;本文在这里智慧园区大屏可以监测哪些内容、监测的意义、监测的方式等&#xff0c;欢迎点…
阅读更多...
LangChain核心解析：掌握AI开发的“链“式思维

LangChain核心解析：掌握AI开发的“链“式思维

0. 思维导图 1. 引言 🌟 在人工智能快速发展的今天，如何有效地利用大语言模型(LLM)构建强大的应用成为众多开发者关注的焦点。前面的课程中，我们学习了正则表达式以及向量数据库的相关知识，了解了如何处理文档并将其附加给大模型。本章我们将深入探讨LangChain中的核心概…
阅读更多...
思维链编程模式下可视化医疗编程具体模块和流程架构分析（全架构与代码版）

思维链编程模式下可视化医疗编程具体模块和流程架构分析（全架构与代码版）

引言 随着人工智能在医疗领域的广泛应用&#xff0c;医疗AI思维链可视化编程工具应运而生&#xff0c;旨在为非技术背景的医疗从业者提供便捷的AI模型开发平台。这个工具通过直观的可视化界面&#xff0c;简化了AI模型的构建过程&#xff0c;帮助用户高效完成数据处理、模型训…
阅读更多...
AI与玩具结合的可行性分析

AI与玩具结合的可行性分析

文章目录 一、市场需求&#xff1a;教育与陪伴的双重驱动&#xff08;一&#xff09;教育需求&#xff08;二&#xff09;情感陪伴需求&#xff08;三&#xff09;消费升级 二、技术发展&#xff1a;赋能玩具智能化&#xff08;一&#xff09;AI技术的成熟&#xff08;二&#…
阅读更多...
软考又将迎来新的改革？

软考又将迎来新的改革？

3月26日&#xff0c;工信部所属事业单位发布了一则招聘公告&#xff0c;其中&#xff0c;工信教考中心面相符合条件的博士招聘1名“考务处技术研究岗”的人员&#xff0c;具体岗位内容&#xff1a; 其岗位简介中&#xff0c;有一条“研究、制定考试技术改革方案&#xff0c;并组…
阅读更多...
怎么让一台云IPPBX实现多家酒店相同分机号码一起使用

怎么让一台云IPPBX实现多家酒店相同分机号码一起使用

下面用到的IPPBX是我们二次开发后的成品&#xff0c;支持各种云服务器一键安装&#xff0c;已经写好了一键安装包&#xff0c;自动识别系统环境&#xff0c;安装教程这里就不再陈述了&#xff01; 前言需求 今天又遇到了一个客户咨询&#xff0c;关于部署一台云IPPBX&#xf…
阅读更多...
蓝桥杯2024JavaB组的一道真题的解析

蓝桥杯2024JavaB组的一道真题的解析

文章目录 1.问题描述2.问题描述3.思路分析4.代码分析 1.问题描述 这个是我很久之前写的一个题目&#xff0c;当时研究了这个题目好久&#xff0c;发布了一篇题解&#xff0c;后来很多人点赞&#xff0c;我都没有意识到这个问题的严重性&#xff0c;我甚至都在怀疑自己&#xf…
阅读更多...
计算机视觉算法实战——基于YOLOv8的行人流量统计系统

计算机视觉算法实战——基于YOLOv8的行人流量统计系统

✨个人主页欢迎您的访问 ✨期待您的三连 ✨ ✨个人主页欢迎您的访问 ✨期待您的三连 ✨ ✨个人主页欢迎您的访问 ✨期待您的三连✨ ​​​ ​​​​​​​​​ ​​ 引言：智能客流分析的市场需求 在零售、交通、安防等领域，准确的行人流量统计对于商业决策、公共安全管理…
阅读更多...
机器学习ML极简指南

机器学习ML极简指南

机器学习是现代AI的核心&#xff0c;从推荐系统到自动驾驶&#xff0c;无处不在。但每个智能应用背后&#xff0c;都离不开那些奠基性的模型。本文用最简练的方式拆解核心机器学习模型&#xff0c;助你面试时对答如流&#xff0c;稳如老G。 线性回归 线性回归试图通过"最…
阅读更多...
flux绘画模型介绍

flux绘画模型介绍

一、Flux绘画模型的核心定义与背景 Flux绘画模型是由Black Forest Labs开发的先进AI图像生成模型&#xff0c;其核心团队源自Stable Diffusion的创始成员&#xff08;如Robin Rombach&#xff09;&#xff0c;结合了Stability AI的技术积累与创新突破。该模型于2024年8月首次发…
阅读更多...
LLM驱动的智能体：基于GPT的对话智能体开发指南

LLM驱动的智能体：基于GPT的对话智能体开发指南

前言 大语言模型&#xff08;LLM, Large Language Model&#xff09;正在彻底改变智能体&#xff08;Agent&#xff09;的设计和实现方式。从简单的聊天机器人到复杂的自动化助手&#xff0c;基于GPT等LLM的对话智能体已经在客服、教育、办公自动化、编程助手等领域得到了广泛…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023