当前位置： 首页 > news >正文

【C++基本功】OOA OOD OOP面向对象彻底详解

news 2025/10/22 10:14:52

好的！我们来彻底、系统地讲解 OOA、OOP 和 OOD，这三个概念是面向对象（Object-Oriented）软件开发中最核心的三个层次，分别代表：

🧩 一、总览：OOA、OOP、OOD 是什么？

缩写全称中文说明
OOAObject-Oriented Analysis面向对象分析分析阶段：弄清楚系统要解决什么问题，有哪些对象和它们之间的关系
OODObject-Oriented Design面向对象设计设计阶段：设计出对象的结构、类之间的关系、接口、行为等，为编码做准备
OOPObject-Oriented Programming面向对象编程编码实现阶段：使用面向对象的编程语言（如 C++、Java）实际编写代码

简单来说：

OOA 是“分析要做什么”，OOD 是“设计怎么做”，OOP 是“动手实现出来”。

这三个环节共同构成了一个完整的面向对象软件开发流程，是构建高质量、易维护、易扩展软件系统的基础。

一、OOA（面向对象分析）

1. 什么是 OOA？

OOA（Object-Oriented Analysis，面向对象分析） 是软件开发过程中的初期阶段，目标是理解用户需求，并通过面向对象的思想来识别问题域中的对象、类、它们的属性和行为，以及对象之间的关系。

🎯 核心任务：搞清楚系统要解决什么问题，有哪些实体，它们之间如何交互。

2. OOA 的主要目标

  • 理解用户需求（与客户/产品经理沟通）

  • 识别问题领域中的对象（Objects）

  • 确定每个对象的属性（Attributes）和行为（Methods/Services）

  • 确定对象之间的关系（如关联、聚合、组合、依赖、继承等）

  • 不涉及具体技术实现，只关注“是什么”，而不是“怎么做”

3. OOA 常用方法与工具

  • 用例分析（Use Case Analysis）：描述用户如何与系统交互

  • 对象建模：找出问题域中的关键对象

  • 实体关系图（ERD）（有时用于数据为中心的系统）

  • UML（统一建模语言）图：如用例图、类图（初步）、活动图等

  • 名词提取法：从需求文档中提取名词，可能是潜在的对象

4. 举个例子（简易图书馆系统）

需求：用户可以借书、还书，管理员可以管理图书。

通过 OOA，我们可能会识别出如下对象：

对象属性行为
用户（User）姓名、ID借书、还书
图书（Book）书名、ISBN、作者、是否借出被借出、被归还
管理员（Librarian）姓名、ID添加图书、删除图书、查看借阅记录
借阅记录（Loan）用户、图书、借出时间、归还时间记录借还信息

🔍 OOA 不关心代码怎么写，只关心有哪些对象，它们干嘛的，互相怎么联系。

二、OOD（面向对象设计）

1. 什么是 OOD？

OOD（Object-Oriented Design，面向对象设计） 是在 OOA 的基础上，进一步设计出系统的具体结构，包括：

  • 设计类（Class）的结构

  • 确定类的属性和方法

  • 设计类与类之间的关系（继承、组合、依赖等）

  • 设计接口与抽象

  • 设计模块划分、系统架构、数据流和控制流等

  • 为 OOP（编码）做准备

🎯 核心任务：设计出类以及它们如何协作来实现需求，是架桥阶段，连接分析与实现。

2. OOD 关注的问题

  • 类应该如何划分？职责是否单一？

  • 类之间如何交互？耦合度如何控制？

  • 是否需要抽象类或接口？

  • 如何设计可扩展、可维护、灵活的系统结构？

  • 设计模式的应用（如工厂、单例、观察者等）

  • 数据怎么存储、状态怎么管理

3. OOD 的产出

  • 详细的类图（Class Diagram，UML）

  • 对象协作图 / 时序图

  • 模块划分与接口定义

  • 设计原则的运用（如 SOLID 原则）

  • 系统架构设计（高层模块如何组织）

4. 继续图书馆系统例子（OOD阶段）

在 OOD 阶段，我们会进一步明确：

  • 类的具体属性和方法

  • 类之间的关系（比如 User 和 Book 之间是“借阅”关系）

  • 引入抽象（比如 “可借阅对象” 作为一个接口？）

  • 设计一个 LoanManager 来处理借还逻辑

  • 可能引入设计模式，如：

    • 使用 组合 表示“图书馆包含多个书”

    • 使用 策略模式 处理不同的借阅规则

🔧 设计决策举例：

  • 类 Book 是否直接知道谁借了它？还是通过 Loan 中介？

  • 是否要抽象出一个 “Person” 基类，让 User 和 Librarian 继承？

  • 借阅规则是否可配置？是否需要策略模式？

三、OOP（面向对象编程）

1. 什么是 OOP？

OOP（Object-Oriented Programming，面向对象编程） 是实际使用面向对象的编程语言（如 C++、Java、Python）将设计和分析的结果转化为可运行代码的过程。

🎯 核心任务：用代码实现类、对象、继承、多态、封装等面向对象特性，真正构建出软件系统。

2. OOP 的四大基本特性（核心！）

特性说明作用
封装（Encapsulation）将数据和操作数据的方法封装在类中，隐藏内部实现细节提高安全性、降低耦合、易于维护
继承（Inheritance）子类继承父类的属性和方法，实现代码复用和层次分类实现代码复用，建立类之间的“is-a”关系
多态（Polymorphism）同一个接口调用，可以根据对象类型执行不同的行为提高灵活性和扩展性，实现接口统一、行为多样
抽象（Abstraction）提取出共同特征形成概念或类的过程，隐藏复杂细节让使用者只关注接口，不关心实现

✅ 这四个特性是面向对象思想的基石，是 OOP 的灵魂。

3. OOP 的关键机制

  • 类与对象

  • 构造函数 / 析构函数

  • 成员函数与数据成员（属性）

  • 访问控制（public / protected / private）

  • 继承（单继承、多继承）

  • 虚函数与多态

  • 抽象类与接口（纯虚函数）

  • 运算符重载、友元、模板（C++特有）

4. 实际编码（以 C++ 为例）

比如，根据前面的图书馆系统，我们可能会实现如下类：

class Book {
private:std::string title;std::string isbn;bool isBorrowed;
public:Book(std::string t, std::string i);void borrow();void returnBook();bool getBorrowedStatus() const;
};class User {
private:std::string name;
public:void borrowBook(Book& b);void returnBook(Book& b);
};

然后在 OOP 阶段，你用 C++、Java 等语言把这些设计真正实现为可运行的程序。

四、OOA、OOD、OOP 三者的关系与流程

可以把它们看作软件开发中的三个层次，一个比一个更接近实际代码：

需求分析↓
OOA（分析阶段） ——> 明确有哪些对象，它们干嘛的，什么关系↓
OOD（设计阶段） —> 设计类结构、接口、交互、架构，准备实现↓
OOP（编程阶段） —> 用面向对象语言（如 C++）真正写出代码

🔁 这三者不是完全割裂的，在实际项目中往往相互交织、循环迭代。需求变更可能导致 OOA 重新分析，进而影响 OOD 和 OOP。

五、补充：面向对象的设计原则（重要！）

无论是在 OOD 还是 OOP 阶段，都应遵循一些重要的设计原则，最常见的就是 SOLID 原则：

原则含义作用
S - 单一职责原则 (SRP)一个类只负责一项职责降低复杂度，提高可维护性
O - 开放封闭原则 (OCP)对扩展开放，对修改关闭易于扩展，不易出错
L - 里氏替换原则 (LSP)子类对象能够替换父类对象保证继承合理，多态可靠
I - 接口隔离原则 (ISP)不强迫客户依赖它们不用的接口减少耦合
D - 依赖倒置原则 (DIP)依赖抽象，而非具体实现提高灵活性与可测试性

✅ 这些原则是写出高质量面向对象代码的指导方针。

六、总结：OOA、OOD、OOP 一句话概括

概念一句话解释
OOA分析阶段：弄清系统要解决什么问题，有哪些对象和它们干嘛的
OOD设计阶段：设计出类、对象、关系、接口，为编码做准备
OOP编程阶段：用面向对象语言（如 C++）把设计变成实际代码

🎓 学习建议与路径

如果你想真正掌握面向对象开发，建议按如下顺序学习：

  1. 先学 OOP 基础语法（比如 C++ 的类、对象、继承、多态等）

  2. 理解 OOP 的四大特性与设计原则

  3. 学习 UML 建模（特别是类图、用例图）

  4. 通过案例练习 OOA（分析需求，找出对象）

  5. 练习 OOD（画类图，设计类结构与交互）

  6. 最后用代码实现（OOP）

✅ 总结 Checklist

项目是否掌握
OOA 是分析问题、识别对象与关系✅
OOD 是设计类结构、接口、对象协作✅
OOP 是用编程语言实现类与对象✅
理解封装、继承、多态、抽象✅
了解 SOLID 原则等设计思想✅
能通过案例进行 OOA → OOD → OOP 全流程思考✅

好的！下面我将通过一个完整的 案例实战，带你一步一步体验 OOA（面向对象分析）→ OOD（面向对象设计）→ OOP（面向对象编程） 的全过程。

我们选择一个经典、简单但涵盖面广的案例：

🎯 案例名称：简易图书馆管理系统

🧩 一、OOA（面向对象分析）—— 分析阶段

1. 🎯 问题描述（需求）

我们需要实现一个简易的图书馆管理系统，满足以下基本功能：

  • 图书馆中有多本图书，每本图书有书名、编号（ISBN）、作者等信息，以及是否已借出的状态；

  • 系统中有读者（用户），读者可以借书和还书；

  • 每本图书一次只能被一个读者借阅；

  • 系统可以查询某本书是否可借，以及谁借了哪本书；

  • （简化）暂时不涉及逾期、罚款、多本借阅等复杂逻辑。

2. 🧠 分析：找出对象（Entities）

从需求中，我们可以提取出几个主要的实体（对象）：

对象说明
Book（图书）表示一本具体的书，有书名、编号、作者、是否借出等属性
User（读者/用户）表示借书的用户，有姓名等属性，能借书和还书
Library（图书馆）管理所有的图书和用户借阅行为（可选，作为协调者）

3. 🔄 对象之间的关系

  • 一个 Library 包含多个 Book

  • 一个 User 可以借阅多个 Book（简化：一次一本）

  • 一个 Book 只能被一个 User 借阅（借阅关系）

4. 📋 对象的属性与行为（初步）

对象属性行为（方法）
Book书名、ISBN、作者、是否借出、借阅者借出、归还、查询状态
User姓名、ID（可选）、当前借的书借书、还书
Library图书列表、用户列表添加图书、查询图书、办理借还

🎯 注意：这一步我们只关心“有哪些对象，它们干嘛的”，不涉及代码实现，也不纠结具体技术。

🧩 二、OOD（面向对象设计）—— 设计阶段

1. 🎨 设计思路

我们要把这些对象设计成类（Class），并明确：

  • 每个类的属性（数据成员）

  • 每个类的方法（成员函数）

  • 类与类之间的关系（组合 / 依赖）

  • 简单的交互流程

2. 🏗️ 类设计（核心类）

📦 类 1：Book（图书）

  • 属性：

    • std::string title（书名）

    • std::string isbn（编号）

    • std::string author（作者）

    • bool isBorrowed（是否借出）

    • User* borrower（当前借阅者，可为 nullptr）

  • 方法：

    • borrow(User* user)：借出给某个用户

    • returnBook()：归还图书

    • isAvailable()：是否可借

    • getInfo()：打印图书信息

📦 类 2：User（用户）

  • 属性：

    • std::string name（姓名）

    • Book* borrowedBook（当前借的书，可为 nullptr）

  • 方法：

    • borrowBook(Book* book)：尝试借阅一本书

    • returnBook()：归还当前图书

    • getInfo()：打印用户信息

📦 类 3：Library（图书馆，协调者，可选但推荐）

  • 属性：

    • std::vector<Book*> books（图书列表）

    • std::vector<User*> users（用户列表）

  • 方法：

    • addBook(Book* book)：添加新书

    • addUser(User* user)：注册用户

    • findBookByISBN()：根据编号查找书

    • listAvailableBooks()：列出可借阅的书

    • （可扩展：借书 / 还书流程控制）

3. 🤝 类之间的关系

  • Library 拥有多个 Book 和 User（组合关系）

  • Book 与 User 之间是借阅关系（一个 Book 只能被一个 User 借）

  • 类之间通过指针或引用交互，避免不必要的拷贝

4. 🧩 设计原则应用（简要）

  • 单一职责原则：Book 只管书的信息与借还，User 只管用户行为

  • 松耦合：Library 作为中间人协调借还，不把逻辑全塞到一个类里

  • 开闭原则：未来可以扩展新功能（如逾期管理）而不用大改现有代码

🧩 三、OOP（面向对象编程）—— C++ 实现阶段

下面给出一个简化版本的 C++ 实现，包含核心功能。

📌 代码环境：C++11 或以上

📦 1. Book 类

#include <iostream>
#include <string>class User; // 前向声明class Book {
private:std::string title;std::string isbn;std::string author;bool isBorrowed;User* borrower; // 当前借阅者public:Book(std::string t, std::string i, std::string a): title(t), isbn(i), author(a), isBorrowed(false), borrower(nullptr) {}void borrow(User* user) {if (!isBorrowed) {isBorrowed = true;borrower = user;std::cout << "Book \"" << title << "\" borrowed by user.
";} else {std::cout << "Book \"" << title << "\" is already borrowed.
";}}void returnBook() {if (isBorrowed) {std::cout << "Book \"" << title << "\" returned by user.
";isBorrowed = false;borrower = nullptr;} else {std::cout << "Book \"" << title << "\" was not borrowed.
";}}bool isAvailable() const { return !isBorrowed; }std::string getTitle() const { return title; }std::string getISBN() const { return isbn; }void display() const {std::cout << "Book: " << title << " (ISBN: " << isbn << ", Author: " << author<< ") - Status: " << (isBorrowed ? "Borrowed" : "Available") << "\n";}
};

📦 2. User 类

class Book; // 前向声明class User {
private:std::string name;Book* borrowedBook;public:User(std::string n) : name(n), borrowedBook(nullptr) {}void borrowBook(Book* book) {if (borrowedBook == nullptr) {borrowedBook = book;book->borrow(this);} else {std::cout << name << " already has a borrowed book.
";}}void returnBook() {if (borrowedBook != nullptr) {borrowedBook->returnBook();borrowedBook = nullptr;} else {std::cout << name << " has no book to return.
";}}std::string getName() const { return name; }void display() const {std::cout << "User: " << name << (borrowedBook ? " (has borrowed a book)" : " (no book borrowed)") << "\n";}
};

📦 3. Library 类（简化版，协调）

#include <vector>class Library {
private:std::vector<Book*> books;std::vector<User*> users;public:void addBook(Book* book) {books.push_back(book);}void addUser(User* user) {users.push_back(user);}void listBooks() const {std::cout << "\n=== Library Books ===\n";for (const auto& b : books) {b->display();}}void listUsers() const {std::cout << "\n=== Library Users ===\n";for (const auto& u : users) {u->display();}}
};

🧪 4. main() 函数 —— 测试运行

int main() {// 创建图书馆Library lib;// 创建图书Book book1("The C++ Programming Language", "978-0321563842", "Bjarne Stroustrup");Book book2("Design Patterns", "978-0201633610", "Erich Gamma");// 创建用户User user1("Alice");User user2("Bob");// 注册到图书馆lib.addBook(&book1);lib.addBook(&book2);lib.addUser(&user1);lib.addUser(&user2);// 展示初始状态lib.listBooks();lib.listUsers();// 借书操作user1.borrowBook(&book1);  // Alice 借书1user2.borrowBook(&book1);  // Bob 也想借书1（失败）user2.borrowBook(&book2);  // Bob 借书2// 展示状态lib.listBooks();lib.listUsers();// 还书user1.returnBook();user2.returnBook();return 0;
}

✅ 本案例覆盖的知识点总结

阶段内容是否涵盖
OOA分析需求，找出对象（Book, User, Library），分析它们的属性和行为✅
OOD设计类结构、方法、关系，考虑交互流程与职责分配✅
OOP用 C++ 实现类、对象、方法调用、模拟借还流程✅
OOP 特性封装（数据与行为在一起）、组合（Library 包含 Book/User）、简单的交互逻辑✅
设计原则单一职责、松耦合、开闭原则（可扩展）✅

🎓 下一步学习建议

如果你想进一步深化，可以：

  1. 为系统添加更多功能：

    • 借阅记录、借书期限、逾期提醒

    • 每个用户可借多本书

    • 用文件保存 / 加载数据

  2. 引入设计模式：

    • 如 Factory 模式创建 Book/User

    • 观察者模式通知用户还书

  3. 使用 UI 或数据库：

    • 做成带图形界面或 Web 的图书馆系统

  4. 练习更多案例：

    • 在线购物系统（商品、订单、用户）

    • 学生成绩管理系统

    • 银行账户管理系统

📩 总结

步骤内容说明
OOA分析需求，找出对象（Book, User, Library）明确“有哪些东西，它们干嘛的”
OOD设计类、方法、关系设计“它们怎么协作，结构如何”
OOP用 C++ 编写代码实现功能实际“动手写出来”

好的！咱们不用一堆术语和枯燥的定义，就用最生活化、最形象、最轻松的方式，来帮你真正理解 OOA、OOD、OOP 这三个听起来高大上，其实和我们日常生活息息相关的概念。

🎯 先问你个问题 👇

想象你要开一家小餐馆，你该怎么一步步把这件事儿从“脑子里的一个想法”变成“真的能开门迎客的店”呢？

你可能会经历这么几个阶段：

🍽️ 类比：开餐馆 = 做软件

开餐馆的步骤软件开发的步骤对应概念
1. 想清楚：我要开什么餐馆？卖啥菜？服务哪些客人？厨房怎么安排？1. 想清楚：我要做个什么软件？解决啥问题？有哪些角色？他们干啥？OOA（分析）
2. 画菜单、设计厨房动线、安排服务员和厨师分工、决定点菜流程2. 设计：我要有哪些“角色”（类）、他们有啥属性和能力、怎么互动OOD（设计）
3. 招人、买锅碗瓢盆、按照设计真的把餐馆开起来，开始营业！3. 编程：用代码把类、对象、功能真的写出来，跑起来！OOP（编程实现）

是不是瞬间觉得亲切多了？那我们就用这个开餐馆的比喻，来生动形象地理解 OOA、OOD、OOP。

🧩 一、OOA（面向对象分析）——“我要开个啥餐馆？”

🤔 问题：你是要解决啥问题？

在软件开发里，这叫需求分析；在开餐馆这事儿里，就是：

我要开一个什么样的餐馆？是川菜馆？西餐厅？快餐店？

我主要服务哪些顾客？上班族？学生？家庭？

我要卖哪些菜？需要哪些厨师和服务员？

顾客怎么点菜？怎么上菜？怎么结账？

这就是分析阶段：弄明白你要做的东西到底长啥样，有哪些角色，他们要干啥。

🍔 类比到 OOA：

  • 对象（角色）可能是：顾客、服务员、厨师、菜品、餐桌、收银台……

  • 他们的行为：顾客点菜、服务员记录、厨师做菜、收银员结账……

  • 他们之间的关系：顾客找服务员，服务员找厨师，厨师给服务员菜，服务员给顾客上菜……

👉 OOA 就是：在动手之前，先搞清楚——有哪些东西（对象）、它们干嘛的、怎么互相配合。

🔍 核心就一句话：你想做一个什么东西？里面有哪些“角色”？他们要干啥？

🧩 二、OOD（面向对象设计）——“我怎么设计我的餐馆？”

🛠️ 问题：现在你知道要干啥了，那具体怎么设计这个餐馆呢？

你开始：

  • 画菜单

  • 安排厨房布局

  • 设计点菜流程

  • 决定谁找谁：顾客找服务员，服务员找厨师……

  • 规划桌椅摆放、后厨动线、收银方式

这就是设计阶段：你开始设计整体结构、流程、角色分工，确保一切井井有条。

🍳 类比到 OOD：

  • 你开始设计一个个“类”：比如 Customer（顾客类）、Waiter（服务员类）、Chef（厨师类）、Dish（菜品类）

  • 你定义每个类的属性（比如 Dish 有名字、价格、口味）和方法（比如 Chef 能 cook()，Waiter 能 takeOrder()）

  • 你设计它们之间怎么交互：比如顾客点菜 → 服务员记录 → 厨师做菜

  • 你还会考虑：如何让流程更顺畅？如何避免服务员太忙？如何让顾客等待时间短？

👉 OOD 就是：在写代码之前，先设计好——类怎么划分？它们有什么功能？它们怎么一起合作？

🔍 核心就一句话：怎么把分析出来的那些“事情和角色”，合理地设计成一个个模块（类），让它们能高效协作？

🧩 三、OOP（面向对象编程）——“我开始真的造餐馆了！”

🏗️ 问题：设计图有了，菜单画好了，现在干啥？

开干！你开始：

  • 招聘厨师和服务员（实例化对象）

  • 按照设计摆桌子、装点菜系统

  • 真的让顾客进来点餐，服务员记录，厨师做菜，最后上菜收钱！

这就是编程实现阶段：你用代码把设计变成现实，让系统真正跑起来。

🛠️ 类比到 OOP：

  • 你打开你的 IDE（比如 Visual Studio、CLion），开始用 C++ / Java / Python 写代码

  • 你把之前设计好的类，比如 Customer、Dish、Waiter，用代码真正写出来

  • 你创建对象：比如 Customer alice;，Dish spicyBeef("辣子牛肉", 38);

  • 你调用方法：比如 waiter.takeOrder(alice, spicyBeef);，chef.cook(spicyBeef);

👉 OOP 就是：用编程语言（比如 C++）把类、对象、方法这些概念，变成真正的、可运行的代码！

🔍 核心就一句话：用代码把“类和对象”实现出来，让它们按照设计去工作！

🎨 总结一下（超级形象版）

阶段比喻说明对应概念
OOA想清楚开啥餐馆，服务谁，有啥菜，谁干啥分析需求，找出有哪些“对象/角色”，它们干嘛的，怎么交互面向对象分析（OOA）
OOD画菜单、设计厨房、安排流程、定义谁找谁设计类、对象、方法、关系，规划好整体结构面向对象设计（OOD）
OOP招人、买设备、按设计真的开店营业用代码实现类和对象，让系统跑起来面向对象编程（OOP）

🧠 再通俗地总结三大概念

概念生活化比喻简单定义
OOA（分析）想清楚你要干啥事，有哪些角色，他们干嘛的分析问题，找出系统中的对象和它们的关系
OOD（设计）设计这些角色怎么配合，流程怎么走，谁找谁设计类、对象、方法、交互，为编码做准备
OOP（编程）真正动手把设计变成能运行的系统用代码实现类与对象，让它们真正工作起来

🎓 举个简单例子巩固一下（学习版）

假设你要设计一个“电子宠物”系统：

🧠 OOA（分析）：

  • 有哪些对象？→ 宠物（Pet）、主人（Owner）

  • 宠物有啥？→ 名字、饥饿度、快乐度、健康值

  • 主人有啥？→ 可以喂食、陪玩、看病

  • 它们咋互动？→ 主人照顾宠物，宠物状态变化

🎨 OOD（设计）：

  • 设计类：

    • Pet 类：属性有 name, hunger, happiness, health；方法有 eat(), play(), checkStatus()

    • Owner 类：方法有 feed(), playWith(), takeToVet()

  • 它们怎么交互？→ Owner 调用 Pet 的方法来照顾它

💻 OOP（编程）：

  • 用 C++ / Python 写：

    pet.eat();
owner.feed(pet);

  • 创建对象，调用方法，实现功能！

✅ 最后送你一句超好记的口诀 🧠

先想清楚要干啥（OOA），再设计好咋干（OOD），最后动手真的干（OOP）

http://www.dtcms.com/a/512176.html

相关文章：

  • 切换/获取root权限
  • 爬虫 beautifulSoup 方法
  • 深入BERT内核:用数学解密掩码语言模型的工作原理
  • 在webos中，在桌面上添加应用
  • 【Spring Security】授权（一）
  • 数据结构八大排序：快速排序-挖坑法（递归与非递归）及其优化
  • Docker 中卷、容器、镜像的区别
  • 学习React-21-受控组件非受控组件
  • 银行测试学习计划
  • 电商自建站中企动力网站建设公司
  • 怎么搜 织梦的网站唐山海港经济开发区人才网
  • Qt打包工具Enigma Virtual Box
  • 【同步/异步 日志系统】--- 介绍
  • 【软考备考】 数据与文件的加解密种类详解和使用场景
  • GitLab 版本控制与管理指南
  • Python动态方法调用全解：从字符串到执行的艺术
  • Blender入门学习03
  • 网站建设龙兵科技嘉兴网站建设网站建设
  • html代码下载网站怎么优化关键词
  • Kafka面试精讲 Day 27：监控告警与故障排查
  • C++ ABI：编译报错之：gcc 4.8.1 切 gcc 6.1.0
  • OLED-on-silicon（OLEDoS）技术正成为VR/MR设备显示技术的未来大趋势
  • QML学习笔记（四十四）QML与C++交互：对QML对象设置objectName
  • 网站制作全包多少钱演出票务网站建设
  • 用 Go 手搓一个 NTP 服务：从“时间混乱“到“精准同步“的奇幻之旅
  • 如何设计一个高并发系统？
  • 仓颉语言核心技术全解析与实战教程
  • 【多维聚类算法】RQ-Kmeans 利用残差信息 捕捉细节特征
  • 【代码随想录算法训练营——Day44】动态规划——1143.最长公共子序列、1035.不相交的线、53.最大子序和、392.判断子序列
  • 北住房和城乡建设厅网站亦庄建设局网站