C++中类，对象，封装，继承（派生），多态

文章目录

• 1.类
• 2.对象
• 3.封装
• 4.继承（派生）
• 5.多态

1.类

类就是同一类事物的总称，比如我（一个对象）可以讲话，那么基本上所有人都具备这个属性，就将我这一类的对象称为类，类的思想就是这样产生的。更恰当的描述：类就是世间事物的抽象称呼，而对象就是这个事物相对应的实体，人类就是一个类，写博文的我，看博文的你就是人类这个类的实例化，这也是为什么人类里面有个类，动物类，植物类，都有一个类，单说一个动物类，我们只能知道是动物，，却无法确定是那种动物，而对象就是具体实例化动物。在C++语言中，类中对象的行为是以函数（方法）的形式定义的，对象的属性是以成员变量的形式定义的，而类包括对象的属性和函数。

在C语言中，我们经常用到被称之为结构体的一个东西

struct {
	char name[10];
	int age;
};

何时使用结构体？当我们需要处理自定义数据类型，结构体是一种很好的选择，结构体的默认访问权限是public（公开）的，也只能是public，并且没有this指针，不支持任何函数，也不可以继承，它体现在将不同数据类型的进行封装，并且仅仅是用于不同类型数据的封装。

而C++中的类在C结构体的基础上，除了public访问，还增加了private（私有），protected（保护），并且默认是private。

除此之外，类还增加了this，函数，继承。

类是反映现实事物的一种抽象，而结构体的作用只是一种包含了具体不同类别数据的一种包装，相对于结构体，类的概念更加牛逼。

让我们看一个最简单的类

class Animal {
	string name;
	int age;
};

是不是感觉只是将struct换成了class，表面是这样，实际区别就是面向过程和面向对象的编程思路。 接下来让我们看什么是对象。

2.对象

现实世界中，随处可见的一种事物就是对象，对象是事物存在的实体，比如人，桌子，电脑，眼前的屏幕。在计算机的世界中，面对对象程序设计的思想要以对象来思考问题，首先要将现实的实体抽象为对象，然后考虑这个对象所具备的属性和行为，比如现在正在写这篇博文的我，就是一个对象，将我抽象为对象，然后识别这个对象的属性，对象具备的属性都是静态属性，比如我是男的，身高168，可以说话等等，接着识别这个对象的动态行为，如睡觉，看书，写博文。当识别出这个对象的属性和行为后，这个对象就被定义完成了，然后可以根据再根据我，了解其他人，可以将这些人特有的属性和行为封装起来来描述人，由此可见，类实质上就是封装对象属性和行为的载体，而对象则是类抽出来的一个实例。

实例化一个对象(在这之前，先把类中成员变量设置为public)，有两种方法

//第一种
Animal dog; 
dog.name = "花狗"; //注意这种实例化，用的是.,表示dog是一个对象或者结构体
dog.age = 21;

//第二种
Animal * cat = new Animal(); //后面这个函数被称为构造函数
cat->name = "花猫";//注意这种实例化，用的是->,->是成员提取,cat只能是指向类、结构、联合的指针
cat->age = 21;

以上两种方式皆可实现类的实例化，有new的区别在于：

1.前者在栈中分配内存（一般用.），后者为动态内存分配，在堆中（一般用->），在一般应用中是没有什么区别的，但动态内存分配会使对象的可控性增强。 2.不加new在堆栈中分配内存 3.大程序用new，小程序直接申请 4.只是把对象分配在堆栈内存中 5.new必须delete删除，不用new系统会自动回收内存

小知识：

站在操作系统的角度 栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。 站在数据结构的角度 有栈(又叫堆栈)和堆，这个是数据结构里面的定义，和操作里面的定义不同。

3.封装

面向对象程序设计具有：封装性，继承性，多态性。 封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想，就比如我们使用一个库函数时，我们只需要知道它的作用就可以了，没必要去了解它的内部工作，比如print函数，我们只需要知道用它可以输出我们我们想输出的内容即可，更通俗的讲，我们只需要写完博文点击发布就可以，而不用去管它如何上传至互联网，采用封装的思想保证了类内部数据结构的完整性，使用该类的用户不能轻易地直接操作此数据结构，只能执行类允许公开的数据，这也就避免了外部操作对内部数据的影响，提高了程序的可维护性。

//Animal.h
class Animal {
//将成员变量设置为私有，保证安全
private:
	string name;
	int age;
	//赋值
	void setName(String name);
	void getAge(int age);
	//取值
	String getName();
	int getAge();
	//利用Setter:赋值 Getter:取值的方式，隐藏内部实现细节，保证代码的安全，同时也可以提升数据的安全性
};
//通常将类的声明和定义分别写在头文件和源文件中，这里有利于可读和修改。
//Animal.cpp
void Animal::setName(String name)
{
	this.name = name;
}
void Animal::setAge(int age)
{
	this.age= age;
}
String Animal::getName(String name)
{
	return this.name;
}
int Animal::getAge(int age)
{
	return this.age;
}
//在C++里面，每一个对象都能通过this指针来访问自己的地址,通俗一点就是，谁调用，this就指向谁。

int main
{
Animal * cat = new Animal(); //后面这个函数被称为构造函数
//cat->name = "花猫";
//cat->age = 21; 现在这两种都是错误的方式，并且变量都暴露在了外面

cat->setName("花猫");
cat->setAge(21);

//使用这种方式，我们不必关心函数内部如何处理，也无法直接接触到类成员变量，这便体现了封装和安全
	return 0;
}

4.继承（派生）

类和类之间具有关系，比如老师类和学生类，学电脑的一类人和学英语的一类人，当处理一个问题时，我们可以将一些有用的类保留下来，在遇到同样的问题时拿来复用，做一个不恰当的比喻，学电脑的现在要读一篇英文文章，假设他们英语很烂，这时应该想到学英语的人，我们可以使用学英语这类人特殊的属性，我们不看其他属性，我们只使用会英语这门属性，这样就节省了学电脑的还需要学习英语来读英语文章，这样就大大节省了学电脑的时间，这就是继承的基本思想，可见设计软件的代码时可以使用继承思想来缩短软件开发的时间，复用那些以前已经定义好的类，提高系统性能，减少系统在使用过程中出现错误的几率，这就是为什么有些人写完一个功能会把代码保存起来，下次需要这个需求，我们就可以拿来代码直接用。 在C++中，人类这种大类被称为父类，而学习电脑，学习英语这几类人被称为子类，他们都是父类分离出来的，他们有着必然的联系，他们都是人。

下面的例子和上面的例子无关，我们继续拿Animal这个类说。

Animal这个类已经定义了名字和年龄，如果我们现在想要定义一只猫(cat类)，它也有名字和年龄，和发出的声音，就可以在Animal类的基础上进行添加声音即可，这种操作被称为是继承，cat类继承于Animal类，也可以说成事cat类是Animal的派生类。

想要继承Animal这个类，需要加入这个类的头文件。

#include "Animal.h"

class cat:public Animal //表示cat类继承于Animal这个类，至于前面的public，我们先不管
{
	String sound;
	//添加对应的get/set
	void setSound(String sound);
	String getSound();
}

实例化cat类对象

Cat cat = new Cat();
cat->setName("花猫");
cat->setAge(21);
cat->setSound("喵喵喵");

5.多态

多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）。根据调用对象的不同方法执行不同的内容，多态具体表现在重写和重载，就是类的多种表现方式比如同名不同参子类重写父类。重载发生在一个类中.重写发生在子类,意思就是子类重写父类相同名称的方法。

重载的特性：方法名相同.返回类型,传入方法的参数不同(包括个数和类型)。 重载是编译时期的多态，又叫静态多态，编译时期的多态是靠重载实现的，根据参数个数，类型和顺序决定的（必须在同一个类中）

重写的特性：方法名相同,返回类型,参数均相同,必须发生在子类。 重写是运行时的多态，在运行时根据实际情况决定调用函数

下面的print函数有三种重载（为了方便观察，我将声明和定义写在一块），会在编译时，根据参数不同，返回值不同选择不同的类型。

class Animal
{
	String name;
	int age;
	
	void print(String name)
	{
		cout<<name;
	}
	void print(int age)
	{
		cout<<age;
	}
	void print(String name,int age)
	{
		cout<<name<<age;
	}
};

下面来看重写的例子，在运行中决定行为

class Animal {
public:
	string name;
	int age;
	virtual void print()
	{
		cout << "我不会叫" << endl;
	}
};
class dog :public Animal
{
public:
	virtual void print()
	{
		cout << "汪汪"<<endl;
	}
};
class cat :public Animal
{
public:
	virtual void print()
	{
		cout << "喵喵"<<endl;
	}
};

int main()
{
	Animal * animal1 = new dog();
	animal1->print();
	Animal * animal2 = new cat();
	animal2->print();
	return 0;
}

virtual：虚函数是指一个类中你希望重载的成员函数 ，当你用一个基类指针或引用 指向一个继承类对象的时候，调用一个虚函数时, 实际调用的是继承类的版本。