C/C++基础知识复习（44）

1) C++ 中多态性在实际项目中的应用场景

多态性是面向对象编程（OOP）中的一个重要特性，指的是不同的对象可以通过相同的接口来表现不同的行为。在 C++ 中，多态通常通过虚函数（virtual）和继承机制来实现。实际项目中，多态性广泛应用于以下几个场景：

1.1) 图形用户界面（GUI）框架

在图形界面编程中，不同的控件（如按钮、文本框、复选框等）通常是从一个基类（如 Widget 或 UIElement）继承而来。基类声明一个虚函数（如 draw()），不同的控件通过重写该函数实现不同的绘制方式。这样，程序可以通过统一的接口来操作这些不同类型的控件，而不需要关心它们的具体类型。

class Widget { 
public: virtual void draw() = 0; 
// 纯虚函数 
virtual ~Widget() {
} }; 
class Button : public Widget { 
public: void draw() override { cout << "Drawing Button" << endl; 
} }; 
class TextBox : public Widget { 
public: void draw() override { 
cout << "Drawing TextBox" << endl; 
} }; 
void render(Widget* widget) { widget->draw(); 
// 多态性：不同类型的 Widget 会调用不同的 draw() 
}

1.2) 插件架构（Plugin Architecture）

在需要动态加载插件的系统中，多态性使得可以通过统一的接口与插件进行交互，而不需要在编译时确定插件的具体类型。例如，假设有一个音频处理软件，它可以加载不同的音效插件（如 Echo、Reverb 等），这些插件继承自一个基类 AudioEffect，并且重写一个通用的 apply() 方法。

class AudioEffect { 
public: virtual void apply() = 0; 
// 纯虚函数 virtual ~AudioEffect() {} }; 
class Echo : public AudioEffect { 
public: void apply() override { cout << "Applying Echo effect" << endl; 
} }; 
class Reverb : public AudioEffect { 
public: void apply() override { 
cout << "Applying Reverb effect" << endl; 
} }; 
void applyEffect(AudioEffect* effect) { 
effect->apply(); 
// 多态性：不同类型的 AudioEffect 会调用不同的 apply() 
}

1.3) 游戏开发中的对象行为管理

在游戏开发中，角色、物品、敌人等对象通常都继承自一个基类（如 GameObject），然后根据不同类型的对象实现不同的行为。通过多态性，游戏逻辑可以以统一的方式处理不同类型的对象。

class GameObject { 
public: virtual void update() = 0; 
virtual ~GameObject() {
} }; 
class Player : public GameObject { 
public: void update() override { cout << "Updating player position" << endl; 
} }; 
class Enemy : public GameObject { 
public: void update() override { 
cout << "Updating enemy position" << endl; 
} }; 
void updateGameObjects(vector<GameObject*>& objects) { 
for (auto obj : objects) { obj->update(); // 多态性：调用正确的 update() 
} }

1.4) 数据库访问层

在一些数据库访问系统中，可以通过多态性来统一访问接口。例如，定义一个数据库基类 Database，然后根据数据库的类型（如 MySQL、PostgreSQL、SQLite）实现具体的数据库访问方式。不同类型的数据库对象通过统一的接口进行操作，而不需要关心具体的实现。

class Database { 
public: 
virtual void connect() = 0; virtual void disconnect() = 0; virtual ~Database() {
} }; 
class MySQL : public Database { 
public: 
void connect() override { cout << "Connecting to MySQL database" << endl; 
} 
void disconnect() override { 
cout << "Disconnecting from MySQL database" << endl; 
} }; 
class SQLite : public Database { 
public: void connect() override { 
cout << "Connecting to SQLite database" << endl; 
} 
void disconnect() override { 
cout << "Disconnecting from SQLite database" << endl; 
} }; 
void performDatabaseOperations(Database* db) { 
db->connect(); // 多态性：不同数据库实现不同连接方式 db->disconnect(); 
// 多态性：不同数据库实现不同断开方式 
}

1.5) 策略模式（Strategy Pattern）

策略模式是一个常见的设计模式，允许在运行时选择算法或操作。在 C++ 中，可以通过多态性来实现不同的策略，并且客户端代码可以动态选择使用哪个策略。

class Strategy { 
public: virtual void execute() = 0; virtual ~Strategy() {} 
}; 
class ConcreteStrategyA : public Strategy { 
public: void execute() override { 
cout << "Executing Strategy A" << endl; 
} }; 
class ConcreteStrategyB : public Strategy { 
public: void execute() override { 
cout << "Executing Strategy B" << endl; 
} }; 
class Context { 
private: Strategy* strategy; 
public: Context(Strategy* strat) : strategy(strat) {} 
void setStrategy(Strategy* strat) { 
strategy = strat; 
} 
void executeStrategy() { 
strategy->execute(); // 多态性：执行不同的策略 
} };

2) C++ 中面向对象编程如何实现数据隐藏？

数据隐藏是面向对象编程（OOP）中的一个重要概念，指的是将对象的内部状态（数据成员）隐藏在类的外部，只通过公共的方法（通常是成员函数）来访问和修改这些数据。这有助于保护数据的完整性和安全性，同时使得外部代码无法直接修改类的内部状态，从而减少了潜在的错误和不必要的复杂性。

C++ 实现数据隐藏的主要机制是通过 访问控制（Access Control）来实现的，使用 private 和 protected 等访问修饰符来控制数据的可访问性。

2.1) 使用 private 和 protected 来隐藏数据

• private：表示该成员只能在类的内部访问，外部无法直接访问或修改。
• protected：表示该成员可以在类的内部和派生类中访问，但外部无法访问。
• public：表示该成员可以被外部代码访问。

示例：

class Employee { 
private: int salary; // 隐藏数据，外部无法直接访问 
public: // 构造函数 Employee(int sal) : salary(sal) {} // 公共方法用于访问和修改私有数据 
void setSalary(int sal) { 
if (sal > 0) { // 保护数据的一致性 salary = sal; 
} } 
int getSalary() const { return salary; } }; 
int main() { 
Employee emp(5000); cout << "Salary: " << emp.getSalary() << endl; // 正常访问 emp.setSalary(6000); // 修改数据 cout << "Updated Salary: " << emp.getSalary() << endl; return 0; }

2.2) 友元函数（Friend Function）

虽然 C++ 提供了访问控制机制，但有时候需要允许特定的函数访问类的私有成员。此时可以通过 友元函数 来实现。友元函数并不属于类的一部分，但它可以访问类的私有和保护成员。

class Box { 
private: int length; 
public: Box(int len) : length(len) {} 
// 声明友元函数 
friend void printLength(const Box& b); }; 
// 友元函数可以访问私有数据 
void printLength(const Box& b) { cout << "Length: " << b.length << endl; } 
int main() { 
Box box(10); printLength(box); // 友元函数可以访问私有成员 
return 0; }

2.3) 封装与接口

通过封装技术，可以将类的数据和操作数据的函数捆绑在一起，外部只能通过公共的接口（即类的公共方法）来与类的内部数据交互，从而实现数据隐藏。

通过这样的设计，类的实现细节可以随时改变而不影响外部使用它的代码。比如，你可以在内部实现中更换数据结构，而外部代码并不需要知道这些细节，只需要依赖于类提供的接口。

总结来说，C++ 中通过访问控制修饰符（如 private、protected 和 public）和封装技术来实现数据隐藏，并通过提供公共方法来访问和修改隐藏的数据。数据隐藏的好处在于保护类的内部状态不被外部直接修改，从而保证数据的安全性和一致性。