【C++】解析C++面向对象三要素：封装、继承与多态实现机制

解析C++面向对象三要素：封装、继承与多态实现机制

  • 1. 面向对象设计基石
  • 2. 封装：数据守卫者
    • 2.1 访问控制实现
    • 2.2 封装优势
  • 3. 继承：代码复用艺术
    • 3.1 继承的核心作用
    • 3.2 继承类型对比
    • 3.3 典型应用场景
    • 3.4 构造函数与析构函数处理
      • 3.4.1 构造顺序控制
      • 3.4.2 显式调用基类构造
      • 3.4.3 析构函数特性
    • 3.5 方法覆盖与名称隐藏
      • 3.5.1 函数隐藏现象
      • 3.5.2 正确实现方法覆盖
    • 3.6 多重继承与虚继承
      • 3.6.1 多重继承的内存布局
      • 3.6.2 菱形继承问题
      • 3.6.3 虚继承解决方案
    • 3.7 特殊继承场景处理
      • 3.7.1 继承中的友元关系
      • 3.7.2 final关键字使用
      • 3.7.3 空基类优化（EBCO）
    • 3.8 C++11/14/17继承增强特性
      • 3.8.1 继承构造函数
      • 3.8.2 override与final
    • 3.9 继承与模板的协作
      • 3.9.1 CRTP模式（奇异递归模板模式）
      • 3.9.2 类型特征检查
  • 4. 多态：动态绑定魔法
    • 4.1 多态的本质与分类
      • 4.1.1 多态的核心概念
      • 4.1.2 多态的应用价值
    • 4.2 虚函数机制剖析
      • 4.2.1 虚函数表（vtable）原理
      • 4.2.2 虚函数调用过程
      • 4.2.3 虚函数表构造规则
    • 4.3 虚函数重写规范详解
      • 4.3.1 有效重写条件
      • 4.3.2 现代C++重写控制
      • 4.3.3 常见重写错误
    • 4.4 多态实现话题
      • 4.4.1 动态类型识别（RTTI）
      • 4.4.2 虚函数默认参数陷阱
      • 4.4.3 纯虚函数与抽象类
    • 4.5 现代C++多态增强
      • 4.5.1 类型安全的向下转型
      • 4.5.2 基于概念的接口约束（C++20）
      • 4.5.3 多态值语义（类型擦除）
    • 4.6 最佳实践与陷阱规避
      • 4.6.1 黄金法则
      • 4.6.2 常见陷阱示例
  • 5. 总结

1. 面向对象设计基石

C++作为面向对象编程的典范语言，其核心特性封装、继承和多态构成了现代软件工程的支柱。本篇文章将剖析这三个核心特性的实现机制，着重解析多态实现的关键——虚函数系统。

2. 封装：数据守卫者

2.1 访问控制实现

C++通过访问限定符public、protected、private建立严密的访问控制体系：

class Data {
private:char ch; // 完全封装
protected:short s; // 继承可见
public:int i;  // 公共可见
};

private：仅在类内可见。

protected：非继承关系，类外不可见。

public：类外可见。

2.2 封装优势

  1. 数据隐藏防止意外修改。
class Student {
private:string name;int age;
public:Student() {}Student(string name, int age) {name = name;if (age >= 18 && age < 24) {age = age; // 限制赋值在范围内}else {age = 18;}}
};int main() {Student s;s.age = 99; // 直接访问私有成员变量会报错return 0;
}
  1. 接口与实现解耦。
  2. 保持类不变量的完整性。

3. 继承：代码复用艺术

3.1 继承的核心作用

  • 代码复用：复用基类已有功能。
  • 接口扩展：在派生类中添加新特性。
  • 多态基础：构建类层次结构。

3.2 继承类型对比

继承方式基类public成员基类protected成员基类private成员
publicpublicprotected不可访问
protectedprotectedprotected不可访问
privateprivateprivate不可访问
// 基础继承类型
class Base { /*...*/ };class PublicDerived    : public Base    {};  // 公有继承
class ProtectedDerived : protected Base {};  // 保护继承
class PrivateDerived   : private Base   {};  // 私有继承// 特殊继承形式
class MultipleDerived : public Base1, public Base2 {};  // 多重继承
class VirtualDerived  : virtual public Base {};        // 虚继承

3.3 典型应用场景

公有继承（is-a关系）：

class Animal { /*...*/ };
class Cat : public Animal { /*...*/ };  // 猫是动物

保护继承（实现继承）：

class StackImpl { /*...*/ };
class SafeStack : protected StackImpl { // 隐藏基类接口，仅暴露安全操作
};

私有继承（has-a替代方案）：

class Engine { /*...*/ };
class Car : private Engine { // 汽车使用发动机实现，但不是发动机
};

3.4 构造函数与析构函数处理

3.4.1 构造顺序控制

class Base {
public:Base() { std::cout << "Base constructor" << std::endl; }
};class Derived : public Base {
public:Derived() { std::cout << "Derived constructor" << std::endl; }
};
int main() {Derived d;return 0;
}

构造顺序控制

3.4.2 显式调用基类构造

class Base {
private:int val_;
public:Base(int val) : val_(val) {std::cout << "Base constructor" << std::endl;}
};class Derived : public Base {
public:Derived(): Base(10) { // 显式初始化基类std::cout << "Derived constructor" << std::endl;}
};
int main() {Derived d;return 0;
}
// Base constructor
// Derived constructor

3.4.3 析构函数特性

  • 基类析构函数应声明为virtual。
    • 如果基类析构函数不使用virtual声明，可能会造成资源未能完全释放。
    • 严重后果：
      • **Derived::data**未被释放 → \rightarrow →内存泄漏。
        • 派生类析构函数未执行 → \rightarrow →其他资源（文件句柄、网络连接等）泄漏。
class Base {
public:~Base() { std::cout << "Base析构" << std::endl; }
};class Derived : public Base {int* data;  // 动态资源
public:Derived() : data(new int[1024]) {}~Derived() { delete[] data; std::cout << "Derived析构" << std::endl; }
};int main() {Base* obj = new Derived();delete obj;  // 只调用Base的析构函数！
}
// Base析构

// 正确处理方式
class Base {
public:virtual ~Base() {  // 关键修改std::cout << "Base析构" << std::endl; }
};class Derived : public Base {Derived() : data(new int[1024]) {}~Derived() { delete[] data; std::cout << "Derived析构" << std::endl; }
};int main() {Base* obj = new Derived();delete obj;  // 正确调用Derived析构
}
// Derived析构
// Base析构
  • 析构顺序与构造严格相反。
  • 异常处理需谨慎。

3.5 方法覆盖与名称隐藏

3.5.1 函数隐藏现象

class Base {
public:void func(int) { cout << "Base::func(int)" << endl; }
};class Derived : public Base {
public:void func(double) {cout << "Derived::func(double)" << endl;}
};int main() {Derived d;d.func(10);  // 调用Derived::func(double)d.Base::func(10);  // 显式调用基类版本
}
// Derived::func(double)
// Base::func(int)
  • 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类的函数没有**virtual**声明。此时，基类的函数就会被隐藏（注意别与覆盖混淆）。

3.5.2 正确实现方法覆盖

class Shape {
public:virtual void draw() const {cout << "绘制基本形状" << endl;}
};class Circle : public Shape {
public:void draw() const override {  // C++11显式重写cout << "绘制圆形" << endl;}
};
int main() {Circle c;c.draw();  // 调用Circle的draw方法Shape* s = &c;  // 基类指针指向派生类对象s->draw();  // 调用Circle的draw方法，动态绑定return 0;
}
// 绘制圆形
// 绘制圆形

3.6 多重继承与虚继承

3.6.1 多重继承的内存布局

class BaseA { int a; };
class BaseB { int b; };
class Derived : public BaseA, public BaseB { int c; };

多重继承的内存布局

3.6.2 菱形继承问题

class CommonBase { 
public:int data; 
};
class Base1 : public CommonBase {};
class Base2 : public CommonBase {};
class Diamond : public Base1, public Base2 {};  // 数据冗余int main() {Diamond d;d.data = 10; // 编译错误，因为不清楚是Base1还是Base2的datareturn 0;
}

菱形继承问题

3.6.3 虚继承解决方案

class CommonBase { int data; };
class Base1 : virtual public CommonBase {};
class Base2 : virtual public CommonBase {};
class Diamond : public Base1, public Base2 {};int main() {Diamond d;d.data = 10;  // 唯一副本
}

虚继承实现原理：

  • 引入虚基类指针（vbptr）。
  • 共享基类子对象。
  • 增加运行时开销。

虚基类指针

3.7 特殊继承场景处理

3.7.1 继承中的友元关系

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。

class Base {friend void friendFunction();  // 声明友元函数
private:int secret;
};class Derived : public Base {
private:int data;
};void friendFunction() {Derived d;d.secret = 10;  // 可以访问基类私有成员d.data = 10;  // 不能访问Derived私有成员
}

3.7.2 final关键字使用

final修饰的类不能被继承。

class Base final {};  // 禁止被继承class Derived : public Base {};  // 编译错误class Interface {
public:virtual void func() final;  // 禁止重写
};class Impl : public Interface {void func() override;  // 编译错误
};

3.7.3 空基类优化（EBCO）

class Empty {};
class Derived : private Empty {int value;
};int main() {Derived d;cout << sizeof(d) << endl; // 4
}
// sizeof(Derived) == sizeof(int)

3.8 C++11/14/17继承增强特性

3.8.1 继承构造函数

class Base {
public:Base(int a, double d) {a_ = a;d_ = d;}
private:int a_;double d_;
};class Derived : public Base {using Base::Base;  // 继承构造函数
};

3.8.2 override与final

class Interface {
public:virtual void func() const = 0;  // 纯虚函数
};class Impl : public Interface {
public:void func() const override final {cout << "实现接口的函数" << endl;}
};

3.9 继承与模板的协作

3.9.1 CRTP模式（奇异递归模板模式）

template <typename T>
class Counter {
protected:static int count;
public:Counter() { ++count; }~Counter() { --count; }static int getCount() { return count; }
};class Widget : public Counter<Widget> {};
// 每个Widget类型独立计数

3.9.2 类型特征检查

template <typename T>
class Processor {static_assert(std::is_base_of_v<BaseInterface, T>,"必须继承自BaseInterface");// ...
};

4. 多态：动态绑定魔法

4.1 多态的本质与分类

4.1.1 多态的核心概念

多态是面向对象编程的三大特性之一，允许不同对象对同一消息做出不同响应。C++中多态主要分为两类：

  • **编译时多态：**函数重载、模板。
  • **运行时多态：**虚函数机制。

4.1.2 多态的应用价值

  • 提高代码扩展性。
  • 增强接口统一性。
  • 实现动态行为绑定。
  • 支持复杂系统设计模式。

4.2 虚函数机制剖析

4.2.1 虚函数表（vtable）原理

每个包含虚函数的类都会生成一个虚函数表，存储指向虚函数的指针：

class Animal {
public:virtual void sound() { /* ... */ }virtual ~Animal() = default;
};class Cat : public Animal {
public:void sound() override { /* ... */ }
};

内存布局示意：

Cat对象实例：
+------------------+
| vptr             | --> [Cat::sound()地址]
| Animal成员数据    |     [Animal::~Animal()地址]
| Cat特有数据       |    
+------------------+

4.2.2 虚函数调用过程

  1. 通过对象实例的vptr定位vtable。
  2. 根据函数偏移量获取目标函数地址。
  3. 执行间接调用。
; x86汇编示例
mov rax, [rcx]       ; 获取vptr
call [rax+0]         ; 调用第一个虚函数

4.2.3 虚函数表构造规则

类类型vtable内容
基类基类虚函数地址
派生类重写后的函数地址，未重写的保留基类地址

4.3 虚函数重写规范详解

4.3.1 有效重写条件

  • 基类函数必须声明为virtual。
  • 函数完全一致（C++11后允许返回类型协变）。
  • 访问权限可以不同（但通常不建议）。

协变返回类型示例：

class Base {
public:virtual Base* clone() const { /* ... */ }
};class Derived : public Base {
public:Derived* clone() const override { /* ... */ }  // 合法协变
};

4.3.2 现代C++重写控制

class Interface {
public:virtual void operation() = 0;virtual ~Interface() = default;
};class Implementation : public Interface {
public:void operation() override final {  // 显式标记重写并禁止进一步重写// 具体实现}
};

4.3.3 常见重写错误

  1. 参数列表不匹配：
class Base {
public:virtual void func(int) {}
};class Derived : public Base {
public:void func(double) override {}  // 错误！参数列表不匹配
};
  1. 遗漏virtual关键字：
class Base {
public:void initialize() {}  // 非虚函数
};class Derived : public Base {
public:void initialize() override {}  // 编译错误
};

4.4 多态实现话题

4.4.1 动态类型识别（RTTI）

Base* obj = new Derived();
if (auto d = dynamic_cast<Derived*>(obj)) {// 安全向下转型d->specificMethod();
}

4.4.2 虚函数默认参数陷阱

class Base {
public:virtual void show(int x = 10) {cout << "Base: " << x << endl;}
};class Derived : public Base {
public:void show(int x = 20) override {cout << "Derived: " << x << endl;}
};Base* obj = new Derived();
obj->show();  // 输出Derived: 10（默认参数静态绑定）

4.4.3 纯虚函数与抽象类

class AbstractDevice {
public:virtual void initialize() = 0;  // 纯虚函数virtual ~AbstractDevice() = default;void commonOperation() {  // 可包含具体实现// 通用操作}
};

4.5 现代C++多态增强

4.5.1 类型安全的向下转型

Base* basePtr = new Derived();
if (Derived* derivedPtr = dynamic_cast<Derived*>(basePtr)) {// 安全访问派生类成员
}

4.5.2 基于概念的接口约束（C++20）

template <typename T>
concept Drawable = requires(T t) {{ t.draw() } -> std::same_as<void>;
};void render(Drawable auto& obj) {obj.draw();
}

4.5.3 多态值语义（类型擦除）

#include <memory>
#include <functional>class AnyDrawable {struct Concept {virtual void draw() = 0;virtual ~Concept() = default;};template <typename T>struct Model : Concept {T obj;void draw() override { obj.draw(); }};std::unique_ptr<Concept> ptr;
public:template <typename T>AnyDrawable(T&& obj) : ptr(new Model<std::decay_t<T>>{std::forward<T>(obj)}) {}void draw() { ptr->draw(); }
};

4.6 最佳实践与陷阱规避

4.6.1 黄金法则

  1. 多态基类必须声明虚析构函数。
  2. 优先使用override明确重写意图。
  3. 避免在构造函数/析构函数中调用虚函数。
  4. 谨慎使用多重继承。
  5. 使用只能指针管理多态对象。

4.6.2 常见陷阱示例

切片问题：

class Base { /* 包含虚函数 */ };
class Derived : public Base { /* 添加新成员 */ };void process(Base b) { /* ... */ }Derived d;
process(d);  // 发生对象切片，丢失派生类信息

构造函数中的虚函数调用：

class Base {
public:Base() { init(); }  // 危险！virtual void init() = 0;
};class Derived : public Base {
public:void init() override { /* 此时派生类尚未构造完成 */ }
};

5. 总结

理解封装、继承、多态的底层实现机制，是写出高效C++代码的关键。虚函数系统通过vtable和vptr的协作，在运行时实现动态绑定，这种设计在保持效率的同时提供了极大的灵活性。

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

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

相关文章

Python并发编程：开启性能优化的大门（7/10）

Python并发编程：开启性能优化的大门（7/10）

1.引言 在当今数字化时代&#xff0c;Python 已成为编程领域中一颗璀璨的明星&#xff0c;占据着编程语言排行榜的榜首。无论是数据科学、人工智能&#xff0c;还是 Web 开发、自动化脚本编写&#xff0c;Python 都以其简洁的语法、丰富的库和强大的功能&#xff0c;赢得了广大…
阅读更多...
数学复习笔记 10

数学复习笔记 10

前言 我觉得数学的高分乃至满分属于那些&#xff0c;聪明&#xff0c;坚韧&#xff0c;勇敢&#xff0c;细致的人。我非常惭愧自己不是这样的人&#xff0c;我在生活中发现了这样的同学&#xff0c;和他们交流的时候我常常感到汗流浃背&#xff0c;因为他们非常扎实的基础知识…
阅读更多...
深入理解 Webpack 核心机制与编译流程

深入理解 Webpack 核心机制与编译流程

&#x1f916; 作者简介&#xff1a;水煮白菜王&#xff0c;一位前端劝退师 &#x1f47b; &#x1f440; 文章专栏&#xff1a; 前端专栏 &#xff0c;记录一下平时在博客写作中&#xff0c;总结出的一些开发技巧和知识归纳总结✍。 感谢支持&#x1f495;&#x1f495;&#…
阅读更多...
概率相关问题

概率相关问题

问题汇总 1. 贝叶斯定理&#xff08;贝叶斯公式和全概率公式&#xff09;2. 概率题2.1 随机发生器的概率为1/2 1. 贝叶斯定理&#xff08;贝叶斯公式和全概率公式&#xff09; 定义&#xff1a;在信息和条件有限的情况下&#xff0c;基于过去的数据&#xff0c;通过动态调整的…
阅读更多...
【系统架构师】2025论文《WEB系统性能优化技术》

【系统架构师】2025论文《WEB系统性能优化技术》

&#x1f60a;你好&#xff0c;我是小航&#xff0c;一个正在变秃、变强的文艺倾年。 &#x1f514;本文分享【系统架构师】2025论文《系统可靠性设计》&#xff0c;期待与你一同探索、学习、进步&#xff0c;一起卷起来叭&#xff01; 目录 项目介绍背景介绍系统模块技术栈性能…
阅读更多...
ADS1220高精度ADC（TI）——应用 源码

ADS1220高精度ADC（TI）——应用 源码

文章目录 德州仪器ADS1220概述资料引脚&封装布线寄存器配置寄存器0&#xff08;00h&#xff09;配置寄存器1&#xff08;01h&#xff09;配置寄存器2&#xff08;02h&#xff09;配置寄存器3&#xff08;03h&#xff09; 连续转换流程驱动源码ads1220.cads1220.h 德州仪器A…
阅读更多...
Uniapp 安卓实现讯飞语音听写（复制即用）

Uniapp 安卓实现讯飞语音听写（复制即用）

在移动应用开发中&#xff0c;语音交互功能能够极大提升用户体验&#xff0c;让操作更加便捷自然。讯飞语音听写技术凭借其高准确率和稳定性&#xff0c;成为众多开发者的选择。本文将详细介绍如何在 Uniapp 项目中&#xff0c;实现安卓端的讯飞语音听写功能&#xff0c;帮助你…
阅读更多...
【golang】DNS 资源记录（RR）接口

【golang】DNS 资源记录（RR）接口

Go 中 miekg/dns 包对 DNS 资源记录&#xff08;RR&#xff09;接口 的定义&#xff1a; type RR interface {Header() *RR_HeaderString() stringcopy() RRlen(off int, compression map[string]struct{}) intpack(...)unpack(...)parse(...)isDuplicate(r2 RR) bool }这个接…
阅读更多...
16.2 VDMA视频转发实验之模拟源

16.2 VDMA视频转发实验之模拟源

文章目录 1 实验任务2 系统框图3 硬件设计3.1 IP核配置3.2 注意事项3.3 自定义IP核源码 4 软件设计4.1 注意事项4.2 工程源码4.2.1 main.c文件 1 实验任务 基于14.1&#xff0c;相较于16.1&#xff0c;使用自定义IP核vid_gen_motion替换Xilinx TPG IP核。 2 系统框图 基于14…
阅读更多...
深度学习之用CelebA_Spoof数据集搭建一个活体检测-训练好的模型用MNN来推理

深度学习之用CelebA_Spoof数据集搭建一个活体检测-训练好的模型用MNN来推理

一、模型转换准备 首先确保已完成PyTorch到ONNX的转换&#xff1a;深度学习之用CelebA_Spoof数据集搭建活体检测系统&#xff1a;模型验证与测试。这里有将PyTorch到ONNX格式的模型转换。 二、ONNX转MNN 使用MNN转换工具进行格式转换&#xff1a;具体的编译过程可以参考MNN的…
阅读更多...
JVM学习专题（一）类加载器与双亲委派

JVM学习专题（一）类加载器与双亲委派

目录 1、JVM加载运行全过程梳理 2、JVM Hotspot底层 3、war包、jar包如何加载 4、类加载器 我们来查看一下getLauncher&#xff1a; 1.我们先查看getExtClassLoader() 2、再来看看getAppClassLoader(extcl) 5、双亲委派机制 1.职责明确&#xff0c;路径隔离​&#xff…
阅读更多...
部署安装gitlab-ce-17.9.7-ce.0.el8.x86_64.rpm

部署安装gitlab-ce-17.9.7-ce.0.el8.x86_64.rpm

目录 ​编辑 实验环境 所需软件 实验开始 安装部署gitlab171.配置清华源仓库&#xff08;版本高的系统无需做&#xff09;vim /etc/yum.repos.d/gitlab-ce.repo 2.提前下载包dnf localinstall gitlab-ce-17.9.7-ce.0.el8.x86_64.rpm --rocklinux 3.修改配…
阅读更多...
使用LoRA微调Qwen2.5-VL-7B-Instruct完成电气主接线图识别

使用LoRA微调Qwen2.5-VL-7B-Instruct完成电气主接线图识别

使用LoRA微调Qwen2.5-VL-7B-Instruct完成电气主接线图识别 动机 任务适配需求 Qwen2.5-VL在视觉理解方面表现优异&#xff0c;但电气主接线图识别需要特定领域的结构化输出能力&#xff08;如设备参数提取、拓扑关系解析&#xff09;。微调可增强模型对专业符号&#xff08;如…
阅读更多...
系统集成项目管理工程师学习笔记

系统集成项目管理工程师学习笔记

第九章 项目管理概论 1、项目基本要素 项目基础 项目是为创造独特的产品、服务或成果而进行的临时性工作。 项目具有临时性、独特性、渐进明细的特点。项目的“临时性”是指项目只有明确的起点和终点。“临时性”并一定意味着项目的持续时间短。 项目可宣告结束的情况&…
阅读更多...
Secs/Gem第七讲(基于secs4net项目的ChatGpt介绍)

Secs/Gem第七讲(基于secs4net项目的ChatGpt介绍)

好的&#xff0c;那我们现在进入&#xff1a; 第七讲&#xff1a;掉电重连后&#xff0c;为什么设备不再上报事件&#xff1f;——持久化与自动恢复的系统设计 关键词&#xff1a;掉电恢复、状态重建、初始化流程、SecsMessage 缓存机制、自动重连、事件再注册 本讲目标 你将理…
阅读更多...
室内定位：热门研究方向与未解难题深度解析

室内定位：热门研究方向与未解难题深度解析

I. 引言：对普适性室内定位的持续探索 A. 室内定位在现代应用中的重要性 室内定位系统（IPS）正迅速成为众多应用领域的基石技术，其重要性源于现代社会人们约70%至90%的时间在室内度过的事实 1。这些应用横跨多个行业，包括应急响应 1、智能建筑与智慧城市 6、医疗健康（如病…
阅读更多...
Android学习总结之Glide自定义三级缓存（实战篇）

Android学习总结之Glide自定义三级缓存（实战篇）

一、为什么需要三级缓存 内存缓存&#xff08;Memory Cache&#xff09; 内存缓存旨在快速显示刚浏览过的图片&#xff0c;例如在滑动列表时来回切换的图片。在 Glide 中&#xff0c;内存缓存使用 LruCache 算法&#xff08;最近最少使用&#xff09;&#xff0c;能自动清理长…
阅读更多...
Linux的文件查找与压缩

Linux的文件查找与压缩

查找文件 find命令 # 命令&#xff1a;find 路径范围 选项1 选项1的值 \[选项2 选项2 的值…]# 作用&#xff1a;用于查找文档&#xff08;其选项有55 个之多&#xff09;# 选项&#xff1a;# -name&#xff1a;按照文档名称进行搜索&#xff08;支持模糊搜索&#xff0c;\* &…
阅读更多...
python处理异常，JSON

python处理异常，JSON

异常处理 #异常处理 # 在连接MySQL数据库的过程中&#xff0c;如果不能有效地处理异常&#xff0c;则异常信息过于复杂&#xff0c;对用户不友好&#xff0c;暴露过多的敏感信息 # 所以&#xff0c;在真实的生产环境中&#xff0c; 程序必须有效地处理和控制异常&#xff0c;按…
阅读更多...
线程的两种实现方式

线程的两种实现方式

线程的两种实现方式——内核支持线程&#xff08;kernal Supported Thread, KST&#xff09;&#xff0c; 用户级线程&#xff08;User Level Thread, ULT&#xff09; 1. 内核支持线程 顾名思义&#xff0c;内核支持线程即为在内核支持下的那些线程&#xff0c;它们的创建&am…
阅读更多...
最新文章

Copyright @ 2022~2023