目录
封装
封装的定义
封装是面向对象编程(OOP)中的一个核心概念,它指的是将数据(属性)和操作这些数据的函数(方法)结合在一起的过程,以此来模拟现实世界中的实体。在C++中,封装主要通过类(class)和结构体(struct)来实现,同时使用访问修饰符(public、protected、private)来控制成员的可见性。
这样可以隐藏类的内部实现细节,只暴露出限定的接口供外界访问。
封装的好处
- **数据隐藏**:通过隐藏内部实现细节,只暴露必要的接口,提高代码的安全性。
- **模块化**:将功能划分为独立的模块,有助于降低复杂性,提高代码的可维护性。
- **接口设计**:设计清晰、简单且一致的接口,使库更容易使用。
- **代码重用**:封装可以提高代码的可重用性,因为其他开发者可以在不了解具体实现的情况下使用这些类和对象。
封装的实例
cpp
#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++中,继承的基本语法如下:
cpp
class ParentClass {
// 父类的属性和方法
};
class ChildClass : public ParentClass {
// 子类的属性和方法
};
在这个示例中,`ChildClass` 是 `ParentClass` 的子类,它可以访问 `ParentClass` 中的所有公共方法和属性。
继承的好处
- **代码重用**:子类可以重用父类的代码,避免重复编写相似的代码。
- **易于维护**:当父类中的代码需要修改时,只需修改父类,所有子类将自动继承这些更改。
- **扩展性强**:可以轻松地添加新子类而不需要修改现有代码。
继承的类型
C++支持三种继承类型:
- **公有继承(Public Inheritance)**:子类可以访问父类的所有公共成员和保护成员。
- **保护继承(Protected Inheritance)**:子类可以访问父类的所有保护成员,但父类的公共成员对子类不可见。
- **私有继承(Private Inheritance)**:子类只能访问父类的私有成员,父类的公共和保护成员对子类不可见。
继承的实例
cpp
#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)来实现。
多态的好处
- **代码灵活性**:多态允许我们使用相同的接口来操作不同的对象,而具体的行为由对象的实际类型决定。
- **易于扩展**:当需要添加新的派生类时,只需实现相应的接口,而不需要修改现有代码。
- **代码解耦**:多态有助于降低代码间的耦合度,提高代码的可维护性。
多态的实例
cpp
#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` 方法,实现了多态。