(꒪ꇴ꒪ )，Hello我是祐言QAQ
我的博客主页：C/C++语言，Linux基础，ARM开发板，软件配置等领域博主🌍
快上🚘，一起学习，让我们成为一个强大的攻城狮！
送给自己和读者的一句鸡汤🤔：集中起来的意志可以击穿顽石!
作者水平很有限，如果发现错误，可在评论区指正，感谢🙏

看完这一篇保准你对OOP理解通透了！！！

接下来进入正题！

面向对象编程（OOP）的概念就像是使用一套构造工具来构建真实世界的模型。在这个模型中，对象就像是真实世界中的事物，它具有一些属性（例如颜色、形状、大小）和一些可以执行的操作，我们称之为方法（例如移动、旋转、改变颜色）。这些对象是从一个模具（或者说是蓝图）——类中创建的。

看完上面这段话相信你对面向对象编程有了一个初步且不成熟的理解，那么接下来让我们通过一些简单的C++代码来具体理解这些概念，并尝试成为C++的主人。

一、类与对象

假设我们要模拟一个动物园。我们可以创建一个Animal类，用来描述动物园中的每一个动物。

#include <iostream>

using namespace std;//当我们使用命名空间后，下面标粉的代码就可以省略

class Animal {
public:
    // 数据成员
    std::string name;
    std::string type;
    int age;

    // 成员函数
    void eat() {
        std::cout << name << " is eating.\n";
    }

    void sleep() {
        std::cout << name << " is sleeping.\n";
    }
};

在这个例子中，Animal类定义了三个数据成员（name，type和age）和两个成员函数（eat和sleep）。我们可以根据这个类创建具体的动物对象tiger：

Animal tiger;
tiger.name = "Tiger";
tiger.type = "Carnivore";
tiger.age = 5;

tiger.eat(); // outputs: Tiger is eating.

在上述代码中，tiger是一个Animal对象，它具有自己的名字、类型和年龄，并且可以进行吃和睡觉的操作。

看完这个形象又生动的例子，相信你一定可以理解类和对象了吧，其实这和python中的类和对象的理解几乎可以说一模一样，对于学过python的同学一定深有体会。

二、封装

封装是一种将数据和操作数据的函数绑定到一个实体的机制，它可以隐藏对象的内部状态，并且只通过对象的方法来访问它。这可以防止对象的状态被外部代码随意修改，从而保证数据的安全性。

让我们修改一下Animal类，将数据成员设置为私有，并通过公有的成员函数来访问它们：

class Animal {
private:
std::string name; // 私有成员变量，表示动物的名称
std::string type; // 私有成员变量，表示动物的类型
int age; // 私有成员变量，表示动物的年龄

public:
// 公有成员函数，用于设置动物的名称
void setName(std::string newName) {
name = newName;
}

// 公有成员函数，用于设置动物的类型
void setType(std::string newType) {
type = newType;
}

// 公有成员函数，用于设置动物的年龄
void setAge(int newAge) {
age = newAge;
}

// 公有成员函数，用于描述动物正在进食的行为
void eat() {
std::cout << name << " is eating.\n";
}

// 公有成员函数，用于描述动物正在睡眠的行为
void sleep() {
std::cout << name << " is sleeping.\n";
}
};

现在，我们不能直接访问Animal对象的name，type和age了，而是只能通过setName，setType和setAge的方法来修改它们。说起这些方法，你乍一看肯定觉得好难，但是作为一个已经精通了C的人为什么不能把他们理解为C中的函数定义呢，所以说，学习C++并不难，我认为的核心学习思路就是把C结和python来再看C++，只不过这里的函数不叫函数了，在C++中它们被称为方法（成员函数）。

三、继承

继承是指从已有的类创建新类的机制。新类（派生类）继承了基类的属性和方法，并可以添加新的属性和方法，或者覆盖基类的方法。

让我们创建一个Bird类，它继承自Animal类，并添加了一个新的方法fly：


class Bird : public Animal {
public:
    void fly() {
        std::cout << "The bird is flying.\n";
    }
};

在这个例子中，Bird类继承了Animal类的所有公有和保护成员，因此我们可以像使用Animal对象一样使用Bird对象：

Bird parrot;
parrot.setName("Parrot");
parrot.setType("Herbivore");
parrot.setAge(2);

parrot.eat();  // outputs: Parrot is eating.
parrot.fly();  // outputs: The bird is flying.

四、多态

多态是同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。多态性允许我们将派生类的对象当作基类的对象来使用，从而实现代码的通用性。

让我们为Animal类添加一个makeSound方法，并在Bird类中覆盖它：

class Animal {
private:
std::string name;
std::string type;
int age;

public:
// 公有成员函数，用于描述动物正在发出声音的行为
virtual void makeSound() {
std::cout << name << " is making a sound.\n";
}
};

// 定义一个名为 Bird 的类，继承自 Animal 类
class Bird : public Animal {
public:
// 重写从父类继承的公有成员函数 makeSound
void makeSound() override {
std::cout << "The bird is chirping.\n";
}
};

现在，我们可以创建一个Animal指针指向Bird对象，并调用makeSound方法：

Animal* animal = new Bird();
animal->makeSound(); // 输出: The bird is chirping.

在这个例子中，虽然animal的类型是Animal*，但是调用makeSound方法时，实际执行的是Bird类的版本，这就是多态。

我知道巴巴一大堆不如一个完整例程来的快，那么浅浅展示一下啦：

完成例程：

#include <iostream>
#include <string>

// 定义基类 Animal
class Animal {
private:
    std::string name;  // 私有成员变量，表示动物的名称
    std::string type;  // 私有成员变量，表示动物的类型
    int age;           // 私有成员变量，表示动物的年龄

public:
    // 成员函数：设置动物的名称
    void setName(std::string newName) {
        name = newName;
    }

    // 成员函数：设置动物的类型
    void setType(std::string newType) {
        type = newType;
    }

    // 成员函数：设置动物的年龄
    void setAge(int newAge) {
        age = newAge;
    }

    // 成员函数：描述动物正在发出声音的行为
    virtual void makeSound() {
        std::cout << name << " is making a sound.\n";
    }
};

// 定义派生类 Bird，继承自 Animal
class Bird : public Animal {
public:
    // 成员函数：描述鸟正在飞翔的行为
    void fly() {
        std::cout << "The bird is flying.\n";
    }

    // 重写基类的 makeSound 方法
    void makeSound() override {
        std::cout << "The bird is chirping.\n";
    }
};

int main() {
    // 创建 Animal 对象并设置属性
    Animal tiger;
    tiger.setName("Tiger");
    tiger.setType("Carnivore");
    tiger.setAge(5);

    // 调用基类的 makeSound 方法
    tiger.makeSound();  // 将会输出: Tiger is making a sound.

    // 创建 Bird 对象并设置属性
    Bird parrot;
    parrot.setName("Parrot");
    parrot.setType("Herbivore");
    parrot.setAge(2);

    // 调用派生类的方法和基类的重写方法
    parrot.makeSound(); // 将会输出: The bird is chirping.
    parrot.fly();       // 将会输出: The bird is flying.

    return 0;
}

五、总结

面向对象编程（OOP）是一种强大的编程范式，它通过抽象，封装，继承和多态等机制，将复杂的问题分解为一组互相交互的对象，使代码更易于理解，维护和扩展。这就好比你在玩乐高，每个乐高积木（对象）都有自己的颜色和形状（属性），并且可以与其他积木拼接（方法）。通过组合各种积木，你可以构建出城堡，汽车，飞机等各种模型（程序）。

那么接下来，就跟随我的脚步，在编程的海洋里构建属于自己的城堡吧！！！

更多C语言、Linux系统、ARM板实战和数据结构相关文章，关注专栏：

手撕C语言

玩转linux

脚踢数据结构

6818（ARM）开发板实战