c++ 接口/多态

目次
接口的通用界说
特点：
C++ 中的接口
接口的作用
接口与抽象类的区别
什么是多态？
多态的范例
1. 编译时多态
2. 运行时多态
多态的实现原理
留意事项

在编程中，接口（Interface） 是一个抽象概念，用于界说一组举动规范或功能约定，而不提供具体实现。它是一种左券，规定了实现它的类必须提供哪些方法或功能。接口广泛用于面向对象编程（OOP）中，以实现模块化、解耦和多态。
下面我会从通用概念和 C++ 的角度具体表明“接口”。
接口的通用界说

接口可以看作是类与类之间通讯的桥梁。它只声明方法（或函数）的署名（如名称、参数、返回值范例），而不关心这些方法怎样实现。实现接口的类必须按照接口的界说提供具体实现。
特点：

• 抽象性：接口自己不包罗实现细节。
  
• 欺压性：实现接口的类必须实现全部接口中界说的方法。
  
• 多态性：通过接口范例引用具体实现，可以在运行时动态调用差异类的举动。
  

比喻：接口就像一份条约，规定了“做什么”（what），但不关心“怎么做”（how）。比如，一个“电源插座”接口界说了“提供220V交换电”的规范，具体是水力发电照旧太阳能发电由实现者决定。
C++ 中的接口

C++ 没有像 Java 或 C# 那样的显式 interface 关键字，但通过纯虚函数和抽象类，可以实现接口的功能。具体来说：

• 一个类中全部函数都是纯虚函数（virtual ... = 0）的抽象类，通常被用作接口。
  
• 派生类继承这个抽象类并实现全部纯虚函数。
  

示例：C++ 中的接口 

1. #include <iostream>
2. using namespace std;
4. // 接口（抽象基类）
5. class Printable {
6. public:
7.     virtual void print() const = 0; // 纯虚函数
8.     virtual ~Printable() {}         // 虚析构函数，确保正确清理
9. };
11. // 实现接口的类
12. class Book : public Printable {
13. private:
14.     string title;
15. public:
16.     Book(const string& t) : title(t) {}
17.     void print() const override {
18.         cout << "Book: " << title << endl;
19.     }
20. };
22. class Article : public Printable {
23. private:
24.     string author;
25. public:
26.     Article(const string& a) : author(a) {}
27.     void print() const override {
28.         cout << "Article by: " << author << endl;
29.     }
30. };
32. int main() {
33.     Printable* items[2];
34.     items[0] = new Book("C++ Primer");
35.     items[1] = new Article("John Doe");
37.     for (int i = 0; i < 2; i++) {
38.         items[i]->print(); // 多态调用
39.         delete items[i];
40.     }
41.     return 0;
42. }

复制代码

输出： 

1. Book: C++ Primer
2. Article by: John Doe

复制代码

在这个例子中：

• Printable 是一个接口，界说了 print 方法。
  
• Book 和 Article 是具体类，实现了 Printable 接口。
  
• 通过 Printable* 指针，可以同一调用差异类的 print 方法，实现多态。
  

接口的作用

• 解耦合：
  调用方只依赖接口，不依赖具体实现。比方，main 函数不必要知道 Book 或 Article 的细节，只需知道它们实现了 Printable。
  
• 可扩展性：
  新增一个实现类（如 Magazine）时，无需修改现有代码，只要它实现 Printable 接口即可。
  
• 多态性：
  通过基类指针或引用调用派生类的实现，动态绑定到精确的函数。
  
• 规范化：
  欺压全部实现类提供划一的举动（如 print 方法）。
  

接口与抽象类的区别

在 C++ 中，接口和抽象类都依赖纯虚函数，但它们有渺小区别：

• 接口：通常只包罗纯虚函数，纯粹界说举动规范，没有数据成员或实现。
  
• 抽象类：可以包罗纯虚函数、平常虚函数乃至具体实现，大概尚有数据成员，用于提供部门默认举动。
  

示例（抽象类 vs 接口）：

1. // 接口
2. class ILog {
3. public:
4.     virtual void log(const string& message) = 0;
5.     virtual ~ILog() {}
6. };
8. // 抽象类
9. class Logger {
10. protected:
11.     string prefix;
12. public:
13.     Logger(const string& p) : prefix(p) {}
14.     virtual void log(const string& message) = 0; // 纯虚函数
15.     void info(const string& msg) {               // 提供默认实现
16.         log(prefix + " INFO: " + msg);
17.     }
18. };

复制代码

什么是多态？

多态，字面意思是“多种形态”，在编程中指的是同一个接口或方法可以在差异的对象上表现出差异的举动。换句话说，多态允许用同一的接口调用差异类的实现，而具体实验哪个实现取决于对象的现实范例。
平常表明：多态就像一个遥控器，按下“播放”按钮，差异装备（电视、音响、DVD播放器）会有差异的反应，但你只必要知道“按播放”就行，不消管背后是哪种装备。
多态的范例

在 C++ 中，多态紧张分为两种：

• 编译时多态（Compile-time Polymorphism）
  
  
  
  • 通过**函数重载（Function Overloading）和运算符重载（Operator Overloading）**实现。
    
  • 在编译时就确定调用哪个函数。
    
  
  
• 运行时多态（Run-time Polymorphism）
  
  
  
  • 通过**虚函数（Virtual Function）**和继承实现。
    
  • 在运行时根据对象的现实范例动态决定调用哪个函数。
    
  
  

1. 编译时多态

编译时多态是静态的，依赖函数名雷同但参数差异的重载机制。
示例：函数重载

1. #include <iostream>
2. using namespace std;
4. class Calculator {
5. public:
6.     int add(int a, int b) {
7.         return a + b;
8.     }
9.     double add(double a, double b) {
10.         return a + b;
11.     }
12. };
14. int main() {
15.     Calculator calc;
16.     cout << calc.add(2, 3) << endl;       // 调用 int 版本，输出 5
17.     cout << calc.add(2.5, 3.7) << endl;   // 调用 double 版本，输出 6.2
18.     return 0;
19. }

复制代码

这里 add 函数根据参数范例在编译时选择符合的版本。 
示例：运算符重载

1. class Complex {
2. private:
3.     double real, imag;
4. public:
5.     Complex(double r, double i) : real(r), imag(i) {}
6.     Complex operator+(const Complex& other) {
7.         return Complex(real + other.real, imag + other.imag);
8.     }
9.     void print() {
10.         cout << real << " + " << imag << "i" << endl;
11.     }
12. };
14. int main() {
15.     Complex a(1.0, 2.0), b(3.0, 4.0);
16.     Complex c = a + b; // 重载了 + 运算符
17.     c.print();         // 输出 4 + 6i
18.     return 0;
19. }

复制代码

+ 运算符被重载，编译器根据上下文选择实现。 
2. 运行时多态

运行时多态是动态的，依赖继承和虚函数机制。通过基类指针或引用调用派生类的函数，具体调用哪个版本在运行时决定。
示例：虚函数实现多态

1. #include <iostream>
2. using namespace std;
4. class Animal {
5. public:
6.     virtual void sound() { // 虚函数
7.         cout << "Some generic animal sound" << endl;
8.     }
9.     virtual ~Animal() {}  // 虚析构函数
10. };
12. class Dog : public Animal {
13. public:
14.     void sound() override {
15.         cout << "Woof" << endl;
16.     }
17. };
19. class Cat : public Animal {
20. public:
21.     void sound() override {
22.         cout << "Meow" << endl;
23.     }
24. };
26. int main() {
27.     Animal* animals[2];
28.     animals[0] = new Dog();
29.     animals[1] = new Cat();
31.     for (int i = 0; i < 2; i++) {
32.         animals[i]->sound(); // 运行时根据对象类型调用
33.         delete animals[i];
34.     }
35.     return 0;
36. }

复制代码

输出：

1. Woof
2. Meow

复制代码

• Animal* 指针指向 Dog 或 Cat 对象，调用 sound() 时根据现实对象范例实验对应版本。
  
• 这是运行时多态的核心，依赖虚函数表（vtable）实现。
  

没有虚函数的对比
假如去掉 virtual：

1. class Animal {
2. public:
3.     void sound() {
4.         cout << "Some generic animal sound" << endl;
5.     }
6. };
8. class Dog : public Animal {
9. public:
10.     void sound() {
11.         cout << "Woof" << endl;
12.     }
13. };
15. int main() {
16.     Animal* ptr = new Dog();
17.     ptr->sound(); // 输出 "Some generic animal sound"
18.     delete ptr;
19.     return 0;
20. }

复制代码

没有 virtual，调用的是 Animal 的版本，由于指针范例是 Animal*，这就是静态绑定。 
多态的实现原理

运行时多态依赖虚函数表（vtable）：

• 每个包罗虚函数的类有一个虚函数表，存储虚函数的所在。
  
• 每个对象包罗一个指向其类虚函数表的指针（vptr）。
  
• 调用虚函数时，通过 vptr 查找表中的函数所在，动态调用。
  

过程：

• 编译器在类中插入 vptr。
  
• 对象创建时，vptr 被初始化为指向对应类的 vtable。
  
• 调用虚函数时，步调通过 vptr 找到并实验精确的函数。
  

留意事项

• 性能开销：运行时多态通过 vtable 实现，有少量内存和间接调用的开销。
  
• 虚函数要求：必须通过指针或引用调用，对象直接调用还是静态绑定。
  
• 虚析构函数：基类应有虚析构函数，克制删除派生类对象时资源走漏。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告