前言

面向过程的语法基本复习完了，能记多少全凭天意。
然后就是c++面向对象的特性了，主要是从class类的角度。

正文

OOP(Object Oriented Programming)即面向对象编程。本质上还是一种思想，通过编程中的事物抽象成对象编程。
与此相关的名词还有OOD(面向对象设计)、OOA(面向对象分析)等。

学c++的时候就知道它兼容c语言特性，所以外界的声音就是c++不单单是面向对象的语言。
像java、c#可能就是纯面向对象语言的代表了。

不过毕竟是一种思想抽象，所以也不能百分之百说就是面向对象好，面向对象不好。还是要取决于使用场景。

面向过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include<iostream>

struct NPC{
	int hp;
	int mp;
	char *name;
};

struct MONSTER{
	int hp;
	int mp;
	char *name;
	int damage;
	unsigned price;
};

struct ROLE{
	int hp;
	int mp;
	char *name;
	int damage;
	unsigned diamond;
	char *id;
};

bool Act(ROLE &acter, ROLE &beacter){
	beacter.hp -= acter.damage;
	return beacter.hp > 0;
}

int main(){

	return 0;
}

看面向过程的时候，结构体定义这种人物，函数定义行为或者进行的操作，比如砍了他一下扣多少血之类的。ROLE zs,ls。 Act(zs,ls)

当然稍大的项目，使用c++开发的话，就不会完成使用面向对象的思想，面向过程固然有用武之处

封装

封装就是可以把已有的事物封装成类，这种类可以让指定的属性被外人看到，也可以设置一些不能被外人多看到的属性。
换做代码：

1
2
3
4
5
6
7
8
9
class box
{
public:
	box();
	~box();

private:
//protected:
};

有公有的区域，也有私有的区域。

继承

继承就是让一个类的对象可以获取另一个类的对象的属性。能够按照一定的等级划分。
被继承的类可以称为“基类”、“父类”。
通过继承创建的类一般被称为“子类”、“派生类”的说法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class<派生类名>:<继承方式><基类名>{
    <派生类新定义成员>
};
//例如：
class box{
public:
	box();
	~box();

private:
};

class box1:public box{

};

多态

是对一个类的实例在相同方法，不同情形下有不同的表现。
多态是在继承的基础上实现。

后面在拆开解

类

1
2
3
4
class 类名{
    public:     //公有对象
    private:    //私有对象
}

在封装继承多态的时候举例了代码，定义一个类的模板就是如此。

1
2
3
struct 结构体名称{
    //成员...
};

其实从结构体和类来比较，大致上有相似的感觉，只不过类还能划分对象，还有一些高级的功能。
而且虽然结构体也能塞函数，但是不太好，毕竟设计的目的就是为了涵盖一些变量。

1
2
3
4
5
6
7
8
9
10
class ROLE{
    int hp;
    int mp;
    int damagel
    int diamond;
};

int main(){
    ROLE zs;
}

在没有定义public:的时候，类的成员都是私有的，未公开。像结构体默认就是公有的。

1
2
3
4
5
6
7
8
9
10
11
class ROLE{
public:
    int hp;
    int mp;
    int damage;
    int diamond;
};

int main(){
    ROLE zs{100,200,100,100};
}

这样才能合理初始化。

一个角色除了基础属性外，还会有回复的能力

1
2
3
4
5
6
7
8
9
10
11
12
13
class ROLE{
public:
	int hp;
	int mp;
	int damage;
	int diamond;

private:
	int hpadd;
	void Init(){
		hpadd = 3;
	}
};

当然这种每秒回多少，我们肯定不希望被其他人访问修改。所以将这个变量放入private:中。
不过每次初始化要调用的函数放到里面的话不利于调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class ROLE{
public:
	int hp;
	int mp;
	int damage;
	int diamond;

	void Init(){
		hpadd = 3;
	}
private:
	int hpadd;
	
};

这样一来，每次创建一个对象，都可以通过对象.Init();去初始化这个hpadd。

然后就是关于对象定义的问题，公有变量都存在public中，但是它可以多次定义：

1
2
3
4
5
6
7
8
9
10
class ROLE{
public:
	int hp;
	int mp;
private:
    int hpadd;
public:
	int damage;
	int diamond;
};

因为还是处于public:下所以还是能够被外部访问，但是不是很建议这么写，太麻烦了。

结语

简单过一遍封装继承多态的概念，和class创建的方式。