目录
封装
封装的定义
封装是面向对象编程（OOP）中的一个核心概念，它指的是将数据（属性）和操作这些数据的函数（方法）结合在一起的过程，以此来模拟现实世界中的实体。在C++中，封装主要通过类（class）和结构体（struct）来实现，同时使用访问修饰符（public、protected、private）来控制成员的可见性。
这样可以隐藏类的内部实现细节，只暴露出限定的接口供外界访问。
封装的好处
- **数据隐藏**：通过隐藏内部实现细节，只暴露必要的接口，提高代码的安全性。
- **模块化**：将功能划分为独立的模块，有助于降低复杂性，提高代码的可维护性。
- **接口设计**：设计清晰、简单且一致的接口，使库更容易使用。
- **代码重用**：封装可以提高代码的可重用性，因为其他开发者可以在不了解具体实现的情况下使用这些类和对象。
封装的实例
#include <iostream>
#include <string>
class Animal {
private:
std::string name;
int age;
public:
// 设置名字的方法
void setName(const std::string& n) {
name = n;
}
// 设置年龄的方法
void setAge(int a) {
age = a;
}
// 获取名字的方法
std::string getName() const {
return name;
}
// 获取年龄的方法
int getAge() const {
return age;
}
};
int main() {
Animal dog;
dog.setName("Buddy");
dog.setAge(3);
std::cout << "Name: " << dog.getName() << ", Age: " << dog.getAge() << std::endl;
return 0;
}
在这个示例中，我们定义了一个名为 `Animal` 的类，它具有两个私有成员变量 `name` 和 `age`。我们没有直接访问这些变量，而是通过公共成员函数（`setName`、`setAge`、`getName` 和 `getAge`）来设置和获取它们的值。这就是封装的一个典型应用。
继承
继承的定义
继承是面向对象编程中的一个核心概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。通过继承，子类可以重用父类的代码，减少重复代码，提高代码的可维护性和可扩展性。
继承的基本语法
在C++中，继承的基本语法如下：
class ParentClass {
// 父类的属性和方法
};
class ChildClass : public ParentClass {
// 子类的属性和方法
};在这个示例中，`ChildClass` 是 `ParentClass` 的子类，它可以访问 `ParentClass` 中的所有公共方法和属性。
继承的好处
- **代码重用**：子类可以重用父类的代码，避免重复编写相似的代码。
- **易于维护**：当父类中的代码需要修改时，只需修改父类，所有子类将自动继承这些更改。
- **扩展性强**：可以轻松地添加新子类而不需要修改现有代码。
继承的类型
C++支持三种继承类型：
- **公有继承（Public Inheritance）**：子类可以访问父类的所有公共成员和保护成员。
- **保护继承（Protected Inheritance）**：子类可以访问父类的所有保护成员，但父类的公共成员对子类不可见。
- **私有继承（Private Inheritance）**：子类只能访问父类的私有成员，父类的公共和保护成员对子类不可见。
继承的实例
#include <iostream>
#include <string>
// 基类 Animal
class Animal {
protected:
std::string name;
int age;
public:
// 设置名字的方法
void setName(const std::string& n) {
name = n;
}
// 设置年龄的方法
void setAge(int a) {
age = a;
}
// 获取名字的方法
std::string getName() const {
return name;
}
// 获取年龄的方法
int getAge() const {
return age;
}
};
// 派生类 Dog，继承自 Animal
class Dog : public Animal {
public:
// Dog 类特有的方法
void bark() const {
std::cout << "Woof! Woof!" << std::endl;
}
};
int main() {
Dog myDog;
myDog.setName("Buddy");
myDog.setAge(3);
myDog.bark();
std::cout << "Name: " << myDog.getName() << ", Age: " + std::to_string(myDog.getAge()) << std::endl;
return 0;
}在这个示例中，我们定义了一个名为 `Animal` 的基类，它具有两个受保护的成员变量 `name` 和 `age`，以及一些公共成员函数（`setName`、`setAge`、`getName` 和 `getAge`）。然后，我们定义了一个名为 `Dog` 的派生类，它继承自 `Animal` 类。`Dog` 类具有一个特有的方法 `bark`。在 `main` 函数中，我们创建了一个 `Dog` 类的对象，并调用了它的方法。
多态
多态的定义
多态 (Polymorphism)：多态是指允许不同的类具有相同的接口，但具体实现方式可能不同。这使得我们可以使用相同的接口来操作不同的对象，而具体的行为由对象的实际类型决定。
C++ 中实现多态主要通过虚函数（virtual function）和纯虚函数（pure virtual function）来实现。
多态的好处
- **代码灵活性**：多态允许我们使用相同的接口来操作不同的对象，而具体的行为由对象的实际类型决定。
- **易于扩展**：当需要添加新的派生类时，只需实现相应的接口，而不需要修改现有代码。
- **代码解耦**：多态有助于降低代码间的耦合度，提高代码的可维护性。
多态的实例
#include <iostream>
#include <string>
// 基类 Animal
class Animal {
public:
// 虚函数 makeSound，实现多态
virtual void makeSound() const {
std::cout << "The animal makes a sound." << std::endl;
}
};
// 派生类 Dog，继承自 Animal
class Dog : public Animal {
public:
// 重写基类的 makeSound 方法
void makeSound() const override {
std::cout << "Woof! Woof!" << std::endl;
}
};
// 派生类 Cat，继承自 Animal
class Cat : public Animal {
public:
// 重写基类的 makeSound 方法
void makeSound() const override {
std::cout << "Meow! Meow!" << std::endl;
}
};
int main() {
Animal* animal1 = new Dog();
Animal* animal2 = new Cat();
animal1->makeSound(); // 输出 "Woof! Woof!"
animal2->makeSound(); // 输出 "Meow! Meow!"
delete animal1;
delete animal2;
return 0;
}
在这个示例中，我们定义了一个名为 `Animal` 的基类，它具有一个虚函数 `makeSound`。然后，我们定义了两个派生类 `Dog` 和 `Cat`，它们分别重写了 `makeSound` 方法。在 `main` 函数中，我们创建了两个 `Animal` 类型的指针，分别指向 `Dog` 和 `Cat` 类的对象，并调用了它们的 `makeSound` 方法。由于 `makeSound` 是虚函数，因此实际调用的是派生类的 `makeSound` 方法，实现了多态。