【C++ | 面向对象思想】 C++ 的面向对象(OOP)思想详解：抽象、封装、继承、多态

😁博客主页😁：🚀https://blog.csdn.net/wkd_007🚀
🤑博客内容🤑：🍭嵌入式开发、Linux、C语言、C++、数据结构、音视频🍭
⏰发布时间⏰：2024-05-30 16:22:47
本文未经允许，不得转发！！！

---

🎄一、概述

面向对象思想最初可以追溯到20世纪60年代和70年代，由Simula、Smalltalk等编程语言的开发者首次提出。然而，面向对象编程的概念在后来的语言中得到了进一步的发展和应用，其中C++和Java等语言对面向对象思想的推广起到了重要作用。

C++是一种支持面向对象编程（OOP）的编程语言，它提供了许多特性和机制来实现面向对象编程思想。以下是C++中常用的面向对象思想：

1. 抽象（Abstraction）：
2. 封装（Encapsulation）：
3. 继承（Inheritance）：
4. 多态（Polymorphism）：
5. 类与对象：类是一种用户定义的数据类型，用于封装数据和方法。对象是类的实例，具有类定义的属性和行为。
   示例：定义一个类Book，包含书的属性（如标题、作者、页数）和方法（如借阅、归还），然后创建Book类的对象实例。

这些面向对象编程思想可以帮助提高代码的可维护性、可重用性和可扩展性，使程序更易于理解和组织。

面向过程和面向对象的区别：下面通过一个例子介绍面向过程和面向对象的区别，一个人把大象装进冰箱，用这两种思想实现如下：

• 面向过程：
  1、把冰箱门打开；
  2、把大象放进冰箱；
  3、把冰箱门关上；
  
  

• 面向对象：
  1、创建两个类：人、冰箱；
  2、创建两个对象：人、冰箱；
  3、让这两个对象去通信，处理把大象装进冰箱。

---

🎄二、抽象（Abstraction）

抽象是将问题的本质特征抽取出来，并根据特征来描述解决方案。
抽象是隐藏对象的复杂性的概念，只显示所需的重要特征，简化了问题的复杂性。

我的理解：抽象是对事物是高度概括，只提取能够表达该事物的重要特征，隐藏事物特有的、复杂的其他特征或概念。例如：对于猫、狗、羊等事物，我们都可以提取它们共有的重要特征（会跑、会吃东西、有四条腿），隐藏复杂的特征(猫吃鱼、狗吃骨头、羊吃草)，根据这些可以对这3个事物进行抽象并命名为动物。动物就是对猫、狗、羊三个事物的一个抽象。

用C++去表示上面的这个抽象过程可以用下面的代码：

#include <iostream>

using namespace std;

class Canimal
{
public:
	int leg;
	void run(){};
	virtual void eat() = 0;// 纯虚函数，Canimal 为抽象基类

protected:
	Canimal(int _leg):leg(_leg){};
};

class Ccat : public Canimal
{
public:
	Ccat(int _leg):Canimal(_leg)
	{
		cout << "create a cat with " << leg << " legs" << endl;
	};
	void eat()
	{
		cout << "eat fish!!!" << endl;
	}
};


class Cdog : public Canimal
{
public:
	Cdog(int _leg):Canimal(_leg)
	{
		cout << "create a dog with " << leg << " legs" << endl;
	};
	void eat()
	{
		cout << "eat bones!!!" << endl;
	}
};

class Csheep : public Canimal
{
public:
	Csheep(int _leg):Canimal(_leg)
	{
		cout << "create a sheep with " << leg << " legs" << endl;
	};
	void eat()
	{
		cout << "eat grass!!!" << endl;
	}
};

int main()
{
	Canimal* pCat = new Ccat(4);
	pCat->eat();
	
	Canimal* pDog = new Cdog(4);
	pDog->eat();
	
	Canimal* pSheep = new Csheep(4);
	pSheep->eat();

	return 0;
}

上述代码定义一个抽象基类 Canimal，包含了纯虚函数eat()，然后派生出Ccat类、Cdog类、Csheep类，实现各自的eat()方法。

运行结果如下：

---

🎄三、封装（Encapsulation）

封装是将数据和操作数据的函数捆绑在一起的概念，隐藏了对象的内部细节，只暴露必要的接口给外部。

封装地两个优点：
• 确保用户代码不会无意间破坏封装对象的状态。
• 被封装的类的具体实现细节可以随时改变 ， 而无须调整用户级别的代码。

接口：接口是一个共享框架， 供两个系统（ 如在计算机和打印机之间或者用户或计算机程序之间 ） 交互时使用。例如，当人们使用电脑时，无法直接将脑子里的词传递到电脑的内存中，必须使用电脑提供的接口来交互，这里的接口可以是鼠标、键盘、屏幕等。在 C++ 的类中，也存在公共接口，这个接口使类的使用者能够编写与类的对象交互的代码。要使用某个类， 必须了解其公共接口，也就是要知道这个接口需要什么参数，做了什么操作，返回什么东西。

访问控制：C++的类可以使用三个关键字来描述对类成员的访问控制，public修饰的成员可以直接被类的对象直接调用，而protect、private修饰的成员无法直接被类对象直接使用。在编写一个类时，可以使用private来修饰成员，将实现细节隐藏起来，这是C++实现封装的一种方式。

🌰例子：类的成员变量和成员函数的访问控制。例如，定义一个类CPerson，将姓名和年龄作为私有成员变量，通过公有成员函数提供对这些数据的访问和修改，将实现细节放在私有方法_eat中，再从公有接口eat来调用_eat，隐藏实现细节，而且在后面如果想到更好的实现，直接修改_eat方法，不会对公有接口有影响。

// 07_Encapsulation.cpp
// g++ 07_Encapsulation.cpp 
#include <iostream>
#include <cstring>

using namespace std;

class CPerson
{
public://公有接口
	void SetName(char *pName){
		strncpy(name, pName, sizeof(name));
	}
	char* GetName(void){
		return name;
	}
	void SetAge(int _age){
		age=_age;
	}
	int GetAge(void){
		return age;
	}
	void eat(){ //公有接口，隐藏实现细节
		_eat();
	}
private:
	char name[64];
	int  age;
	void _eat(){
		cout << "eat rice" << endl;
	}
};
int main()
{
	CPerson XiaoMing;
	XiaoMing.SetName((char*)"XiaoMing");
	XiaoMing.SetAge(18);
	XiaoMing.eat();
	cout << "name = " << XiaoMing.GetName() << ", age = " << XiaoMing.GetAge() << endl;
	return 0;
}

运行结果截图：

---

🎄四、继承（Inheritance）

继承允许一个类（子类）继承另一个类（父类）的属性和方法，以便重用已有的代码并实现代码的层次化组织。子类可以扩展或修改继承的属性和方法。继承是多态的前提。

继承主要用途是将子类存在共性的东西，把它抽取出来放到父类里面，比如将共同拥有的属性和方法抽取出来放到父类里面。
继承的2个好处：
1、想要使用这些属性和方法的时候，可以直接去使用父类的，而不需要自己再重新去定义，更大程度的实现代码复用。
2、我们不需要写很多的冗余的代码，把共性的全部抽到父类，可以直接调用，如果需要个性化自定义子类的方法时，去重写父类的方法即可。

示例：定义一个基类Animal，其中包含run方法，然后派生出子类Cat和Dog，它们继承了Animal的run方法。

// 07_Inheritance.cpp
// g++ 07_Inheritance.cpp 
#include <iostream>

using namespace std;

class Animal{
public:
	void run(){
		cout << "Animal run" << endl;
	}
};

class Cat : public Animal{
	
};

class Dog : public Animal{
	
};

int main ()
{
	Cat cat;
	cat.run();
	
	Dog dog;
	dog.run();
	return 0;
}

---

🎄五、多态（Polymorphism）

多态性允许不同类的对象对同一消息作出响应，即同一函数调用可以有不同的行为，这取决于调用函数的对象。

多态就是调用同一个函数，不同的对象会出现不同的表现。

在C++实现多态有三个必要条件：继承、重写、父类指针或引用指向子类对象。

通过下面这个例子来理解多态：通过虚函数和纯虚函数实现多态。定义一个基类Animal，其中有一个makeSound()虚函数，然后派生出Dog和Cat类，分别重写makeSound()函数以发出不同的声音。
1、继承：Dog 和 Cat 类都继承基类Animal；
2、重写：Dog 和 Cat 类都重写makeSound()函数；
3、父类指针或引用指向子类对象：创建两个基类Animal的指针，分别指向Dog类对象、Cat类对象。

// 07_Polymorphism
// g++ 07_Polymorphism
#include <iostream>

using namespace std;

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

class Dog : public Animal{
	void makeSound(){
		cout << "Dog:汪汪汪" << endl;
	}
};

class Cat : public Animal{
	void makeSound(){
		cout << "Cat:喵喵喵" << endl;
	}
};

int main ()
{
	Animal *pDog = new Dog;
	pDog->makeSound();
	
	Animal *pCat = new Cat;
	pCat->makeSound();
	
	return 0;
}

运行结果：

多态的好处：便于接口的维护和拓展，可以将某一个子类切换成其他的子类，代码不需要做任何的改变，具有可替换性。
多态的弊端：只有是子类重写的父类的方法，父类才可以调用，但如果子类的方法不是重写父类的，而是子类独有的，那么这个时候多态就使用不了，这个是需要注意的点。

---

🎄六、总结

👉本文介绍了面向过程和面向对象的区别，然后介绍了几个面向对象的特性：抽象、封装、继承、多态。

面向对象思想需要在平时看代码和写代码过程中不断积累和套用，并不是看了一篇文章就可以掌握的东西，特别是从面向过程转向面向对象编程会更难。

如果文章有帮助的话，点赞👍、收藏⭐，支持一波，谢谢 😁😁😁

参考：
什么是面向对象? 谈谈你对面向对象的理解