当前位置:

首页 > 编程开发 > C++多态底层原理解析:静态绑定、动态绑定、虚函数表与工程实践

C++多态底层原理解析:静态绑定、动态绑定、虚函数表与工程实践

C++多态底层涉及静态绑定与动态绑定,静态类型编译时确定,动态类型运行时决定。虚函数通过虚函数表实现动态分派,派生类重写虚函数会修改虚表。虚函数导致对象体积增大,构造析构期间不调用派生类版本。动态类型转换和虚函数性能开销需注意。

本文目录

    前言

    在上一篇文章中,我们已经看到多态通常是怎么用的:

    Base* ptr = new Derived;
    ptr->func();

    尽管 ptr 的类型是 Base*,但实际调用的却可能是 Derived::func()。这背后藏着不少值得深挖的问题:

    • 编译器到底怎么知道指针实际指向哪种对象?
    • 静态绑定和动态绑定到底有什么区别?
    • 什么是虚函数表和虚函数表指针?
    • 派生类重写虚函数后,虚表发生了什么变化?
    • 为什么含有虚函数的对象可能会变大?
    • 为什么构造和析构期间不会调用更派生类版本?
    • 如何保存一组不同类型的多态对象?
    • dynamic_cast 应该在什么时候使用?
    • 虚函数会带来多大性能开销?

    本文从底层原理和实际工程两个角度,继续深入讲解 C++ 多态。

    一、静态类型和动态类型

    1.1 静态类型

    静态类型是编译器直接从代码中读到的类型。

    class Animal
    {
    public:
        virtual void talk() const
        {
        }
        virtual ~Animal() = default;
    };
    class Dog : public Animal
    {
    public:
        void talk() const override
        {
        }
    };

    创建对象:

    Dog dog;
    Animal* ptr = &dog;

    这里:

    dog 的静态类型:Dog
    ptr 的静态类型:Animal*
    *ptr 表达式的静态类型:Animal
    

    静态类型在编译阶段就已经确定,无法改变。

    C++多态底层原理解析:静态绑定、动态绑定、虚函数表与工程实践

    1.2 动态类型

    动态类型是对象在程序运行时的实际类型。

    Animal* ptr = &dog;

    虽然 ptr 的静态类型是 Animal*,但它实际指向的是一个 Dog 对象。因此,它指向对象的动态类型是:

    Dog
    

    1.3 两种类型的作用

    对于非虚函数调用:

    ptr->normalFunc();
    

    调用版本主要由静态类型决定。

    对于虚函数调用:

    ptr->talk();
    

    最终版本由对象的动态类型决定。

    简单来说:

    非虚函数看指针或引用声明成什么类型
    虚函数看指针或引用实际指向什么对象

    二、静态绑定和动态绑定

    2.1 静态绑定

    函数调用目标在编译阶段确定,称为静态绑定。

    #include 
    using namespace std;
    class Base
    {
    public:
        void func()
        {
            cout << "Base::func()" << 'n';
        }
    };
    class Derived : public Base
    {
    public:
        void func()
        {
            cout << "Derived::func()" << 'n';
        }
    };
    int main()
    {
        Derived object;
        Base* ptr = &object;
        ptr->func();
        return 0;
    }

    输出:

    Base::func()
    

    因为 func() 不是虚函数,编译器根据 ptr 的静态类型 Base*,直接确定调用 Base::func()。

    2.2 动态绑定

    把基类函数改成虚函数:

    class Base
    {
    public:
        virtual void func()
        {
            cout << "Base::func()" << 'n';
        }
        virtual ~Base() = default;
    };

    派生类完成重写:

    class Derived : public Base
    {
    public:
        void func() override
        {
            cout << "Derived::func()" << 'n';
        }
    };

    再次调用:

    Derived object;
    Base* ptr = &object;
    ptr->func();

    输出变成:

    Derived::func()
    

    函数调用目标需要根据实际对象类型,在运行时确定,这就是动态绑定。

    C++多态底层原理解析:静态绑定、动态绑定、虚函数表与工程实践

    三、多态底层一定使用虚函数表吗?

    先给出一个重要结论:

    C++ 标准规定了虚函数调用应当表现出的行为,但没有强制编译器必须使用某种固定的底层结构。

    主流编译器通常通过下面两个结构实现动态多态:

    vptr:虚函数表指针
    vtable:虚函数表
    

    这是常见实现方式,但不是可以跨平台依赖的语言规则。不同编译器、操作系统和 ABI 可能采用不同的对象布局。

    四、虚函数表指针 vptr

    4.1 普通类对象

    class Normal
    {
    private:
        int _value;
    };
    

    Normal 对象通常只需要保存 _value 以及必要的内存对齐空间。

    4.2 含有虚函数的类

    class Base
    {
    public:
        virtual void func()
        {
        }
    private:
        int _value;
    };

    主流实现通常会在对象中加入一个隐藏指针 vptr,它指向当前对象所属类型的虚函数表。可以抽象理解为:

    Base 对象
    ├── vptr ─────→ Base 虚函数表
    └── _value
    

    4.3 vptr 由编译器维护

    vptr 并不是我们在类中显式声明的成员,它通常由编译器自动添加并维护。对象构造和析构过程中,编译器会根据当前阶段设置对应的虚表指针。

    4.4 vptr 不一定在对象开头

    很多调试器中会看到 vptr 位于对象起始位置,但这不是语言标准保证的。下面这些因素都可能影响对象布局:

    编译器
    ABI
    平台位数
    单继承
    多继承
    虚继承
    成员对齐

    因此,不能通过手工计算固定偏移访问 vptr。

    C++多态底层原理解析:静态绑定、动态绑定、虚函数表与工程实践

    五、虚函数表 vtable

    5.1 虚表存储什么?

    虚函数表可以抽象理解为一个函数地址表。

    class Base
    {
    public:
        virtual void func1()
        {
        }
        virtual void func2()
        {
        }
    };

    对应的虚表可以抽象为:

    Base vtable
    ├── &Base::func1
    └── &Base::func2
    

    对象中的 vptr 指向这张表。

    5.2 同类型对象通常共享虚表

    Base object1;
    Base object2;
    

    两个对象的数据成员相互独立,但它们通常指向同一张 Base 虚表:

    object1.vptr ─┐
                  ├──→ Base vtable
    object2.vptr ─┘
    

    也就是说:

    每个对象保存自己的 vptr
    同类型对象通常共享同一张 vtable

    5.3 虚函数代码不在虚表中

    虚函数和普通函数一样,编译后都是机器指令,通常位于程序的代码区域。虚表中保存的是虚函数地址,或者用于定位虚函数的相关信息,而不是完整的函数代码。

    C++多态底层原理解析:静态绑定、动态绑定、虚函数表与工程实践

    六、派生类的虚函数表

    6.1 基类虚表

    class Base
    {
    public:
        virtual void func1()
        {
            cout << "Base::func1()" << 'n';
        }
        virtual void func2()
        {
            cout << "Base::func2()" << 'n';
        }
    };

    可以抽象成:

    Base vtable
    ├── Base::func1
    └── Base::func2
    

    6.2 派生类重写虚函数

    class Derived : public Base
    {
    public:
        void func1() override
        {
            cout << "Derived::func1()" << 'n';
        }
    
        virtual void func3()
        {
            cout << "Derived::func3()" << 'n';
        }
    };
    

    派生类虚表可以抽象成:

    Derived vtable
    ├── Derived::func1
    ├── Base::func2
    └── Derived::func3
    

    其中:

    func1:派生类完成重写,槽位改为 Derived::func1
    func2:没有重写,继续使用 Base::func2
    func3:派生类新增虚函数
    

    6.3 重写不会修改基类虚表

    Derived 重写 func1() 时,并不是直接修改 Base 的虚表。通常是:

    Base 对象    -> Base vtable
    Derived 对象 -> Derived vtable
    

    两种类型拥有各自对应的虚表。

    C++多态底层原理解析:静态绑定、动态绑定、虚函数表与工程实践

    七、一次虚函数调用的大致过程

    假设:

    Base* ptr = new Derived;
    ptr->func1();
    

    常见实现中的调用过程可以抽象为:

    1. 通过 ptr 找到实际对象
    2. 从对象中读取 vptr
    3. 通过 vptr 找到虚函数表
    4. 找到 func1 对应的虚表槽位
    5. 取得最终函数地址
    6. 调用 Derived::func1
    

    示意:

    Base* ptr
        |
        v
    Derived 对象
    ├── vptr
    │    |
    │    v
    │  Derived vtable
    │  ├── Derived::func1
    │  ├── Base::func2
    │  └── Derived::func3
    │
    └── 数据成员
    

    多态调用的关键不在于变量名叫 ptr,而在于 ptr 实际指向的对象具有什么动态类型。

    C++多态底层原理解析:静态绑定、动态绑定、虚函数表与工程实践

    八、对象大小为什么可能发生变化?

    8.1 普通类

    class Normal
    {
    private:
        int _value;
    };
    

    在常见环境中,对象大小主要由数据成员和内存对齐决定。

    8.2 多态类

    class Base
    {
    public:
        virtual void func()
        {
        }
    private:
        int _value;
    };

    常见实现中,对象还需要保存一个 vptr,因此对象大小可能增加。

    8.3 不要死记固定大小

    在 32 位环境中,指针通常占 4 字节。在 64 位环境中,指针通常占 8 字节。但最终对象大小还会受到成员排列、内存对齐、编译器、ABI、多继承、虚继承等因素影响。

    更准确的说法是:多态对象通常需要额外保存动态分派信息,常见形式是一个或多个虚表指针。

    九、构造期间为什么不会调用派生类版本?

    看下面的代码:

    #include 
    using namespace std;
    class Base
    {
    public:
        Base()
        {
            func();
        }
        virtual void func()
        {
            cout << "Base::func()" << 'n';
        }
        virtual ~Base() = default;
    };
    class Derived : public Base
    {
    public:
        void func() override
        {
            cout << "Derived::func()" << 'n';
        }
    };

    创建对象:

    Derived object;
    

    在 Base 构造函数中执行 func(),调用的是 Base::func(),而不是 Derived::func()。

    9.1 原因

    构造 Derived 时,顺序大致是:先构造 Base 部分,再构造 Derived 部分。执行 Base 构造函数时,Derived 部分还没有完成初始化。如果此时调用 Derived::func(),它可能访问尚未初始化的派生类成员。因此,构造期间的虚函数调用不会分派到更派生类版本。

    C++多态底层原理解析:静态绑定、动态绑定、虚函数表与工程实践

    十、析构期间的虚函数调用

    析构顺序和构造相反:先析构 Derived,再析构 Base。当程序进入 Base 析构函数时,Derived 部分已经被销毁。因此,在基类析构阶段调用虚函数,也不会再分派到 Derived 的重写版本。

    10.1 实际建议

    不要在构造函数和析构函数中依赖运行时多态。尤其不要在基类构造函数中调用需要访问派生类状态的虚函数。更合适的设计包括:

    构造完成后显式调用初始化函数
    使用工厂函数创建对象
    通过构造参数传递必要信息
    把公共初始化放入非虚函数

    十一、访问权限和虚函数重写

    访问权限不会阻止虚函数重写。

    class Base
    {
    public:
        virtual void func()
        {
            cout << "Base::func()" << 'n';
        }
    };
    class Derived : public Base
    {
    private:
        void func() override
        {
            cout << "Derived::func()" << 'n';
        }
    };

    调用:

    Derived object;
    Base& ref = object;
    ref.func();

    这段代码可以通过编译,并调用 Derived::func()。因为:

    是否允许通过 Base 接口调用:检查 Base::func 的访问权限
    最终执行哪个版本:根据动态类型进行虚函数分派
    

    但直接写 object.func(); 会编译失败,因为 Derived::func() 是 private。

    可以简单理解为:

    是否构成重写:看虚函数规则
    能否直接调用:看访问权限

    十二、多继承中的虚表

    简单单继承中,一个多态对象通常表现为一个虚表指针。但在多继承中,一个对象可能包含多个多态基类子对象。

    class Scanner
    {
    public:
        virtual void scan()
        {
        }
        virtual ~Scanner() = default;
    };
    class Printer
    {
    public:
        virtual void print()
        {
        }
        virtual ~Printer() = default;
    };
    class AllInOne : public Scanner, public Printer
    {
    };

    AllInOne 对象可以抽象成:

    AllInOne
    ├── Scanner 子对象
    │   └── Scanner 对应的 vptr
    ├── Printer 子对象
    │   └── Printer 对应的 vptr
    └── AllInOne 自己的成员
    

    因此,不能简单认为每个多态对象一定只有一个 vptr。在多继承、虚继承等复杂场景中,完整对象可能包含多个虚表指针。具体布局属于编译器和 ABI 的实现细节。

    十三、使用智能指针保存多态对象

    13.1 为什么不能用 vector?

    假设:

    class Shape
    {
    public:
        virtual void draw() const
        {
        }
        virtual ~Shape() = default;
    };
    class Circle : public Shape
    {
    public:
        void draw() const override
        {
            cout << "Circle" << 'n';
        }
    };

    如果写:

    vector shapes;
    Circle circle;
    shapes.push_back(circle);

    会把 Circle 按值转换成 Shape,发生对象切片,派生类部分会被舍弃。

    13.2 使用 unique_ptr

    #include 
    #include 
    using namespace std;
    vector> shapes;
    shapes.push_back(make_unique());

    遍历:

    for (const auto& shape : shapes)
    {
        shape->draw();
    }
    

    容器中统一保存 unique_ptr,但每个指针可以指向不同的实际对象,如 Circle、Rectangle、Triangle 等。

    13.3 为什么优先 unique_ptr?

    如果每个对象只有一个明确所有者,通常优先使用 unique_ptr。它能够表达独占所有权,而且不需要手动 delete。只有在确实存在共享所有权时,才考虑 shared_ptr。

    C++多态底层原理解析:静态绑定、动态绑定、虚函数表与工程实践

    十四、完整的多态对象容器示例

    #include 
    #include 
    #include 
    #include 
    #include 
    using namespace std;
    class Shape
    {
    public:
        explicit Shape(string name)
            : _name(std::move(name))
        {
        }
        virtual double area() const = 0;
        virtual void draw() const = 0;
        const string& name() const
        {
            return _name;
        }
        virtual ~Shape() = default;
    private:
        string _name;
    };
    class Circle : public Shape
    {
    public:
        explicit Circle(double radius)
            : Shape("圆形")
            , _radius(radius)
        {
        }
        double area() const override
        {
            return 3.1415926 * _radius * _radius;
        }
        void draw() const override
        {
            cout << "绘制圆形" << 'n';
        }
    private:
        double _radius;
    };
    class Rectangle : public Shape
    {
    public:
        Rectangle(double width, double height)
            : Shape("矩形")
            , _width(width)
            , _height(height)
        {
        }
        double area() const override
        {
            return _width * _height;
        }
        void draw() const override
        {
            cout << "绘制矩形" << 'n';
        }
    private:
        double _width;
        double _height;
    };
    int main()
    {
        vector> shapes;
        shapes.push_back(make_unique(3.0));
        shapes.push_back(make_unique(4.0, 5.0));
        for (const auto& shape : shapes)
        {
            cout << "名称:" << shape->name() << 'n';
            cout << "面积:" << shape->area() << 'n';
            shape->draw();
            cout << 'n';
        }
        return 0;
    }

    新增图形时,只需要增加一个新的派生类,原来的遍历逻辑通常不需要修改。

    十五、RTTI 和 dynamic_cast

    RTTI 是运行时类型识别(Run-Time Type Information)。多态类型可以使用 dynamic_cast 检查实际类型。

    15.1 指针形式

    void process(Shape* shape)
    {
        if (auto* circle = dynamic_cast(shape))
        {
            cout << "当前对象是 Circle" << 'n';
        }
    }

    如果转换成功,返回合法指针;如果失败,返回 nullptr。

    15.2 引用形式

    try
    {
        Circle& circle = dynamic_cast(shape);
    }
    catch (const bad_cast&)
    {
        cout << "转换失败" << 'n';
    }
    

    引用形式转换失败会抛出 std::bad_cast。

    15.3 不要到处使用 dynamic_cast

    如果程序中大量出现 if 是 Circle else if 是 Rectangle else if 是 Triangle,通常说明基类接口设计得不够完整。优先考虑把不同类型的行为设计成虚函数,如 shape.draw()、shape.area()。dynamic_cast 更适合确实需要访问某个派生类专有能力的场景。

    C++多态底层原理解析:静态绑定、动态绑定、虚函数表与工程实践

    十六、虚函数调用的性能成本

    运行时多态并不是完全没有成本。

    16.1 对象空间开销

    多态对象在常见实现中需要保存一个或多个虚表指针。

    16.2 间接函数调用

    普通函数可以直接调用确定地址。虚函数通常需要:读取 vptr、查询虚表、取得函数地址、进行间接调用。

    16.3 可能影响内联

    如果编译器无法确定实际对象类型,虚函数可能难以直接内联。

    16.4 去虚拟化优化

    现代编译器有时能够推断对象的真实类型。例如:

    Derived object;
    object.func();
    

    编译器明确知道对象是 Derived,可能直接调用或内联 Derived::func()。这种优化称为去虚拟化(devirtualization)。

    16.5 是否应该担心虚函数性能?

    大多数普通业务代码中,虚函数的一次间接调用通常不是主要性能瓶颈。是否使用多态,更应该根据设计需求决定。在下面这些场景中才需要重点测量:

    高频调用的底层循环
    游戏引擎核心路径
    高性能计算
    实时系统
    缓存敏感的数据结构

    不要在没有性能测试的情况下,为了避免一次虚调用而破坏代码结构。

    十七、运行时多态和模板多态如何选择?

    C++ 中除了虚函数多态,还有基于模板的静态多态。

    17.1 运行时多态

    void drawShape(const Shape& shape)
    {
        shape.draw();
    }
    

    特点:

    运行时决定类型
    支持统一存储不同派生对象
    接口稳定
    存在虚调用和对象布局开销

    17.2 模板多态

    template
    void drawShape(const T& shape)
    {
        shape.draw();
    }
    

    特点:

    编译期确定类型
    容易内联
    通常没有虚表开销
    不同类型会生成不同模板实例
    难以直接放进同一个值类型容器

    17.3 简单选择建议

    适合运行时多态:

    对象类型需要在运行时决定
    需要插件式扩展
    需要统一保存不同类型对象
    调用者只依赖抽象接口

    适合模板多态:

    类型在编译期已知
    性能和内联非常重要
    不需要运行时替换对象类型
    希望使用泛型算法

    两种方式并不是谁替代谁,而是适用于不同场景。

    C++多态底层原理解析:静态绑定、动态绑定、虚函数表与工程实践

    十八、设计多态体系的建议

    18.1 重写函数始终写 override

    void draw() const override;
    

    可以提前发现函数名写错、参数类型写错、const 遗漏、引用限定符不一致等问题。

    18.2 多态基类设计虚析构函数

    virtual ~Base() = default;
    

    前提是允许通过基类指针销毁派生对象。

    18.3 避免对象切片

    避免:

    void process(Base object);
    vector objects;
    

    优先:

    void process(const Base& object);
    vector> objects;
    

    18.4 使用智能指针管理生命周期

    优先:

    auto ptr = make_unique();
    

    而不是:

    Base* ptr = new Derived;
    // ...
    delete ptr;
    

    18.5 基类接口保持小而稳定

    不要为了某个派生类方便,就把大量特殊功能塞进基类。基类应该描述整个类型体系真正共有的行为。

    18.6 不要在构造和析构中依赖多态

    构造和析构期间不会向更派生类版本分派。

    18.7 不要依赖虚表的具体布局

    下面这些都属于实现细节:

    vptr 位于对象什么位置
    虚表位于哪个内存区域
    虚表末尾有没有空指针
    一个槽位的具体顺序

    可以通过调试器观察,但不能写成可移植代码的依赖。

    十九、常见问题

    19.1 虚函数是否存放在虚表中?

    虚函数代码通常存放在代码区域。虚表中存放的是虚函数地址或相关调度信息。

    19.2 每个对象都有一张虚表吗?

    通常不是。常见情况是:每个对象保存 vptr,同类型对象共享 vtable。

    19.3 每个对象都只有一个 vptr 吗?

    不一定。简单单继承中通常表现为一个。多继承和虚继承中可能存在多个多态基类子对象,因此可能有多个虚表指针。

    19.4 vptr 一定在对象开头吗?

    不一定。对象布局属于编译器和 ABI 的实现细节。

    19.5 虚表末尾一定有 nullptr 吗?

    不一定。不同编译器实现可能不同。

    19.6 普通成员函数会进入虚表吗?

    通常不会。只有参与虚函数机制的成员函数才需要虚表槽位。

    19.7 构造函数可以调用虚函数吗?

    语法上可以。但构造期间不会调用更派生类版本,因此不要依赖这种调用实现多态初始化。

    19.8 dynamic_cast 是否必须依赖多态类?

    向下转换通常要求源类型是多态类型,也就是至少含有一个虚函数。

    19.9 使用虚函数一定很慢吗?

    不一定。虚调用存在间接调用开销,但是否成为瓶颈需要通过实际测量判断。现代编译器还可能进行去虚拟化优化。

    总结

    C++ 多态的常见底层实现可以概括成:

    对象保存虚表指针
    虚表保存虚函数地址
    基类指针或引用调用虚函数
    运行时根据对象虚表选择最终函数

    理解虚函数表的目的,不是让我们在项目中手工修改虚表,而是帮助我们理解:为什么同一个基类指针,可以在运行时调用不同派生类的函数。真正写代码时,仍然应该依赖标准的虚函数、智能指针和类型系统,而不是依赖某个编译器的内部对象布局。

    本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
    作者最新文章
    编程开发
    相关文章 更多
    QQ影音怎么加速播放视频课程
    QQ影音怎么加速播放视频课程

    播放时右键选播放速度,或点控制条倍速,1.25 到 1.5 倍看课最舒服;公式代码类内容别超过 1.25 倍。

    企业微信创建企业提示失败怎么办 实名与填写检查
    企业微信创建企业提示失败怎么办 实名与填写检查

    先看提示属于哪类:名称占用就加后缀,实名不一致就重填本人信息,证件不清晰就重拍。统一社会信用代码逐位核对,连续三次失败别改材料重投,直接联系客服人工核。

    Modern Web Guidance 的 legacy-scan 反转建议应该怎样判断?
    Modern Web Guidance 的 legacy-scan 反转建议应该怎样判断?

    说明源码提交对字符串、生成器和数组的识别边界,以及扫描命令与发行包核验限制。

    Codex 0.170.0 正式版的语音与连接更新,适用范围有哪些限制?
    Codex 0.170.0 正式版的语音与连接更新,适用范围有哪些限制?

    0.170.0 的语音更新限于终端通话协商能力的明确新增,同名工具服务器跨环境支持仍标注实验性质;连接部分则修复大请求回退、认证竞态和云端重连等具体问题。这份正式版公告不足以证明所有账户、所有客户端都已具备完整语音功能。

    Hy4 flash 三种权重怎么选,安装和授权要注意哪些条件?
    Hy4 flash 三种权重怎么选,安装和授权要注意哪些条件?

    了解Hy4 flash、FP8与base的适用任务,阅读官方安装及图文代码,并核对资源和MaaS许可条件。

    OpenAI Python SDK 3.55.0 升级看点:Live MCP 服务配置与预算接口变化
    OpenAI Python SDK 3.55.0 升级看点:Live MCP 服务配置与预算接口变化

    OpenAI Python SDK 3.55.0 升级看点:Live MCP 服务配置与预算接口变化。说明已核实的更新范围、类型兼容性和本地版本确认方法。

    OpenAI Java SDK 4.108.0 的两项新增能力适合哪些项目?
    OpenAI Java SDK 4.108.0 的两项新增能力适合哪些项目?

    OpenAI Java SDK 4.108.0 面向 Live MCP 工具接入与 Managed Agents 预算状态处理,说明新增模型、事件含义、正式发布范围和适用限制。

    Free Claude Code 6.19.37 如何兼顾网页搜索与普通工具调用?
    Free Claude Code 6.19.37 如何兼顾网页搜索与普通工具调用?

    Free Claude Code 6.19.37 在自动搜索时保留客户端工具及选择条件,代理执行搜索后仍返回普通调用。说明适用场景、历史信息保留、请求约束与第三方项目的版本边界。

    Google GenAI Go SDK 1.78.0 的 v1beta 配置优先级怎样判断?
    Google GenAI Go SDK 1.78.0 的 v1beta 配置优先级怎样判断?

    Google GenAI Go SDK 1.78.0 将 Gemini Developer API 默认改为 v1,可用 HTTPOptions.APIVersion 或环境变量保留 v1beta,Vertex AI 默认值不变。

    Google GenAI SDK 3.5.0实时交互值得哪些项目升级评估?
    Google GenAI SDK 3.5.0实时交互值得哪些项目升级评估?

    解释实验性实时支持、环境检查与生产评估中需要验证的条件。

    查看更多
    精品专题 更多
    装机必备
    装机必备

    正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

    Windows
    Windows

    正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

    PDF教程
    PDF教程

    正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

    Mac软件 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    Aperty macOS版
    Aperty macOS版
    macOS

    Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

    WINDOWS 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    PixTV 网页版
    PixTV 网页版
    Windows

    PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。