在 C++ 语言中，面向对象编程（OOP）的核心概念包括 封装 、继承 、重写 、重载 和 多态性。
这些是最基础的知识，现在回顾下。以下是这些概念的详细描述和代码示例：
1. 封装（Encapsulation）
定义 ：封装是将数据和操作数据的方法（函数）捆绑在一起，形成一个独立的单元（即类）。通过访问控制（如 private、protected、public），封装隐藏了对象的内部实现细节，只暴露必要的接口供外部使用。
示例：
#include <iostream>
#include <string>
class Person
{
private:
std::string name; // 私有属性
int age; // 私有属性
public:
// 公有方法：设置姓名
void setName(const std::string& name)
{
this->name = name;
}
// 公有方法：获取姓名
std::string getName() const
{
return name;
}
// 公有方法：设置年龄
void setAge(int age)
{
if (age > 0)
{ // 数据校验
this->age = age;
}
}
// 公有方法：获取年龄
int getAge() const
{
return age;
}
};
int main()
{
Person person;
person.setName("Alice");
person.setAge(30);
std::cout << "Name: " << person.getName() << std::endl; // 输出: Name: Alice
std::cout << "Age: " << person.getAge() << std::endl; // 输出: Age: 30
return 0;
}2. 继承（Inheritance）
定义：继承允许一个类（子类）基于另一个类（父类）来创建，子类继承父类的属性和方法，并可以扩展或修改它们。
示例：
#include <iostream>
#include <string>
// 父类
class Animal
{
protected:
std::string name;
public:
Animal(const std::string& name) : name(name) {}
void speak() const
{
std::cout << name << " makes a sound." << std::endl;
}
};
// 子类
class Dog : public Animal
{
public:
Dog(const std::string& name) : Animal(name) {}
// 重写父类方法
void speak() const
{
std::cout << name << " says Woof!" << std::endl;
}
};
int main()
{
Dog dog("Buddy");
dog.speak(); // 输出: Buddy says Woof!
return 0;
}3. 重写（Override）
定义：重写是指子类重新定义父类中的方法，以改变或扩展其行为。子类的方法名、参数列表必须与父类方法一致。
示例：
#include <iostream>
#include <string>
// 父类
class Animal
{
public:
virtual void speak() const
{
std::cout << "Animal makes a sound." << std::endl;
}
};
// 子类
class Cat : public Animal
{
public:
void speak() const override
{ // 重写父类方法
std::cout << "Cat says Meow!" << std::endl;
}
};
int main()
{
Cat cat;
cat.speak(); // 输出: Cat says Meow!
return 0;
}4. 重载（Overloading）
定义：重载是指在同一个类中定义多个同名方法，但这些方法的参数列表不同（参数类型、数量或顺序）。
示例：
#include <iostream>
class Math
{
public:
int add(int a, int b) const
{
return a + b;
}
double add(double a, double b) const
{ // 重载方法
return a + b;
}
int add(int a, int b, int c) const
{ // 重载方法
return a + b + c;
}
};
int main()
{
Math math;
std::cout << math.add(1, 2) << std::endl; // 输出: 3
std::cout << math.add(1.5, 2.5) << std::endl; // 输出: 4.0
std::cout << math.add(1, 2, 3) << std::endl; // 输出: 6
return 0;
}5. 多态性（Polymorphism）
定义：多态性是指同一个方法在不同对象中具有不同的行为。多态性通常通过继承和重写实现，允许父类引用指向子类对象，并调用子类重写的方法。
示例：
#include <iostream>
#include <memory>
// 父类
class Animal
{
public:
virtual void speak() const
{ // 虚函数
std::cout << "Animal makes a sound." << std::endl;
}
};
// 子类
class Dog : public Animal
{
public:
void speak() const override
{ // 重写父类方法
std::cout << "Dog says Woof!" << std::endl;
}
};
// 子类
class Cat : public Animal
{
public:
void speak() const override
{ // 重写父类方法
std::cout << "Cat says Meow!" << std::endl;
}
};
int main()
{
std::unique_ptr<Animal> animal1 = std::make_unique<Dog>();
std::unique_ptr<Animal> animal2 = std::make_unique<Cat>();
animal1->speak(); // 输出: Dog says Woof!
animal2->speak(); // 输出: Cat says Meow!
return 0;
}总结
| 概念 | 描述 | 示例 |
|---|---|---|
| 封装 | 隐藏内部实现，暴露必要接口。 | 使用 private 和 public 控制访问权限。 |
| 继承 | 子类复用父类的属性和方法。 | class Dog : public Animal |
| 重写 | 子类重新定义父类方法。 | 使用 override 关键字重写虚函数。 |
| 重载 | 同名方法根据参数列表不同实现不同功能。 | 定义多个同名方法，参数列表不同。 |
| 多态性 | 同一方法在不同对象中有不同行为。 | 通过虚函数和父类指针实现。 |
这些概念是 C++ 面向对象编程的核心，掌握它们可以帮助你编写更模块化、可复用和易于维护的代码。