C++ 是一门功能强大的面向对象编程语言，其核心特性之一就是对类与对象的支持。在面向对象编程中，类与对象、继承机制和多态性是理解和实现代码复用、扩展性和灵活性的重要基石。本文将详细介绍这些概念及其在 C++ 中的实现，通过代码示例和分析帮助读者加深理解。

一、类与对象

在 C++ 中，**类（Class）**是面向对象编程的基础，它是用户定义的数据类型，用于封装数据和操作数据的函数。**对象（Object）**是类的实例，表示实际的实体。

1. 类的定义与对象的创建

一个类通常由数据成员（变量）和成员函数（方法）组成。

示例代码

#include <iostream>
#include <string>
using namespace std;

class Person {
private:
    string name;    // 数据成员
    int age;

public:
    // 构造函数
    Person(string n, int a) : name(n), age(a) {}

    // 成员函数
    void introduce() const {
        cout << "Hi, my name is " << name << " and I am " << age << " years old." << endl;
    }

    // 设置年龄
    void setAge(int a) {
        age = a;
    }

    // 获取年龄
    int getAge() const {
        return age;
    }
};

int main() {
    // 创建对象
    Person person("Alice", 25);
    person.introduce();

    // 使用 setter 和 getter 修改并访问私有数据
    person.setAge(30);
    cout << "Updated age: " << person.getAge() << endl;

    return 0;
}

输出结果

Hi, my name is Alice and I am 25 years old.
Updated age: 30

2. 类的重要特性

• 封装性：通过访问修饰符（private、protected、public）保护数据，确保数据的安全性。
• 构造函数：用于初始化对象。
• 析构函数：用于释放资源，避免内存泄漏。
• 成员函数的常量性：通过 const 限定保证函数不会修改对象状态。

二、继承机制

继承是一种面向对象编程的重要机制，用于从已有的类创建新的类。通过继承，子类可以复用父类的成员，并扩展或修改其功能。

1. 继承的基本语法

C++ 使用冒号（:）指定继承类型：

• public 继承：父类的 public 和 protected 成员分别保持为 public 和 protected。
• protected 继承：父类的 public 和 protected 成员都变为 protected。
• private 继承：父类的 public 和 protected 成员都变为 private。

示例代码

#include <iostream>
using namespace std;

class Animal {
public:
    void eat() {
        cout << "I can eat." << endl;
    }

    void sleep() {
        cout << "I can sleep." << endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        cout << "I can bark." << endl;
    }
};

int main() {
    Dog dog;
    dog.eat();     // 继承自 Animal
    dog.sleep();   // 继承自 Animal
    dog.bark();    // Dog 自己的功能

    return 0;
}

输出结果

I can eat.
I can sleep.
I can bark.

2. 继承的分类

• 单继承：一个子类继承自一个父类。
• 多继承：一个子类可以继承自多个父类。
• 多层继承：一个类继承自另一个类，而该类又继承自其他类。

多继承可能会引发 菱形继承问题，需要通过虚继承解决。

菱形继承示例

#include <iostream>
using namespace std;

class A {
public:
    void show() {
        cout << "Class A" << endl;
    }
};

class B : virtual public A {};
class C : virtual public A {};
class D : public B, public C {};

int main() {
    D d;
    d.show();  // 通过虚继承避免歧义
    return 0;
}

三、多态性

多态性是 C++ 的核心特性之一，它允许同一接口具有不同的实现方式，分为编译时多态（静态多态）和运行时多态（动态多态）。

1. 编译时多态

编译时多态通过函数重载和运算符重载实现。

函数重载示例

#include <iostream>
using namespace std;

class Printer {
public:
    void print(int i) {
        cout << "Printing int: " << i << endl;
    }

    void print(double d) {
        cout << "Printing double: " << d << endl;
    }

    void print(string s) {
        cout << "Printing string: " << s << endl;
    }
};

int main() {
    Printer printer;
    printer.print(42);
    printer.print(3.14);
    printer.print("Hello, World!");
    return 0;
}

输出结果

Printing int: 42
Printing double: 3.14
Printing string: Hello, World!

2. 运行时多态

运行时多态通过虚函数（virtual）和继承实现。

虚函数示例

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void sound() {
        cout << "Some generic animal sound" << endl;
    }
};

class Dog : public Animal {
public:
    void sound() override {
        cout << "Bark" << endl;
    }
};

class Cat : public Animal {
public:
    void sound() override {
        cout << "Meow" << endl;
    }
};

int main() {
    Animal* animal;
    Dog dog;
    Cat cat;

    animal = &dog;
    animal->sound();  // 动态绑定，调用 Dog 的 sound()

    animal = &cat;
    animal->sound();  // 动态绑定，调用 Cat 的 sound()

    return 0;
}

输出结果

Bark
Meow

3. 多态的实现原理

运行时多态依赖于 虚函数表（V-Table） 和 虚函数指针（V-Ptr）。每个含虚函数的类都有一个 V-Table，记录虚函数的地址，动态绑定通过查找 V-Table 实现。

四、类与对象、继承和多态的关系

五、总结

C++ 的类与对象、继承机制和多态性为开发者提供了强大的工具来设计灵活且高效的程序。这些特性不仅提高了代码的可读性和可维护性，还为复杂系统的扩展性提供了坚实的基础。在实际编码中，合理地设计类的结构、继承关系和多态性，可以大大提高代码的复用性和灵活性。