C++ （第二天下午---面向对象之类与对象）

一、面向过程与面向对象

1、面向过程
面向过程是一种以事件为中心的编程思想，编程的时候把解决问题的步骤分析出来，然后用函数把这些步骤实现，在一步一步的具体步骤中再按顺序调用函数。

举个例子，下五子棋，面向过程的设计思路是首先分析解决这个问题的步骤：

开始游戏， 
黑子先走， 
绘制画面， 
判断输赢， 
轮到白子， 
绘制画面， 
判断输赢， 
返回步骤2， 
输出最后结果
1
2
3
4
5
6
7
8
9

可见，面向过程始终关注的是怎么一步一步地判断棋局输赢的，通过控制代码，从而实现函数的顺序执行。

2、面向对象（OOP）
在日常生活或编程中，简单的问题可以用面向过程的思路来解决，直接有效，但是当问题的规模变得更大时，用面向过程的思想是远远不够的。所以慢慢就出现了面向对象的编程思想。世界上有很多人和事物，每一个都可以看做一个对象，而每个对象都有自己的属性和行为，对象与对象之间通过方法来交互。面向对象是一种以“对象”为中心的编程思想，把要解决的问题分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描述某个对象在整个解决问题的步骤中的属性和行为。

在下五子棋的例子中，用面向对象的方法来解决的话，首先将整个五子棋游戏分为三个对象:

（1）黑白双方，这两方的行为是一样的。
（2）棋盘系统，负责绘制画面
（3）规则系统，负责判定犯规、输赢等。
1
2
3

然后赋予每个对象一些属性和行为：

第一类对象（黑白双方）负责接受用户输入，并告知
第二类对象（棋盘系统）棋子布局的变化，棋盘系统接收到了棋子的变化，并负责在屏幕上面显示出这种变化，同时利用
第三类对象（规则系统）来对棋局进行判定。

可以看出，面向对象是以功能来划分问题，而不是以步骤解决。比如绘制画面这个行为，在面向过程中是分散在了多个步骤中的，可能会出现不同的绘制版本，所以要考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘系统这个对象中出现，从而保证了绘图的统一。

练习1：使用面向过程的C语言实现面向对象的方法

#include <iostream>

using namespace std;

//C结构体
typedef struct {
    //属性
    char name[256];
    int age;
    int height;
    //行为 --函数指针
    void (*eat)(void);
    void (*playGame)(void);
}GirlFriend_t;

void eat(void)
{
    cout<<"eat"<<endl;
}
void playGame(void)
{
     cout<<"playGame"<<endl;
}


int main()
{
    //结构体的方式
    GirlFriend_t mya ={"如花",28,166,eat,playGame};

    mya.eat();
    mya.playGame();



    return 0;
}
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
35
36
37

练习2：使用C++结构体实现面向对象

#include<iostream>

using namespace std;

//女朋友是一个整体  对象
//关于对象：   1、属性   关于 这个对象的特征的描述  年龄  姓名    变量
//            2、行为   吃饭、打游戏  玩 、睡觉....             函数 
typedef struct GirlFriend{
    //属性
    char name[256];
    int age;
    int money;
    
    //行为
    void eat(){
        printf("[%s] 我正在吃饭....\n",this->name);
    }
    void player(){
        printf("[%s]别说了，上号...\n",this->name);
    }

    int getAge(){
        return this->age;
    }

}GirlFriend_t; 


int main(){

    GirlFriend_t s1 = {"zhang3",22};
    GirlFriend_t s2 = {"ruhua",22};
    
    s1.eat();
    s2.eat();
 
    cout<<s1.getAge()<<endl;
}
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
35
36
37
38

二、类与对象

1、概念
对象：对象是人们要进行研究的任何事物，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。

对象的载体：人、电脑、风扇、桌子、游戏、旅游、棋盘系统.....
对象的描述：
         特征/属性--变量--数据成员 
         功能/方法--函数--函数成员
1
2
3
4

类：具有相同特性（数据元素）和行为（功能）的对象的抽象就是类。因此，对象的抽象是 类，类的具体化（实例化）就是对象，类实际上就是一种数据类型 。

女朋友1  ----有属性（身高、体重、姓名..） 有行为（吃饭、睡觉、打游戏、生气.）
女朋友2  ----有属性（身高、体重、姓名..） 有行为（吃饭、睡觉、打游戏、生气.）
女朋友3  ----有属性（身高、体重、姓名..） 有行为（吃饭、睡觉、打游戏、生气.）
------女朋友1、2、3 是具体的事物(人)，也就是对象
------提炼出共同点，抽象出一个类：GirlFriend类
1
2
3
4
5

2、设计和使用一个类

1） 找出对象 归类 —时间类
2） 抽象：（提炼共同点）
特征/属性：时 分 秒
功能/方法：显示时间 设置时间
3） 封装
把对象的属性和服务结合成一个独立的系统单元。尽可能屏蔽对象的内部细节。对外形成一个边界（或者说一道屏障）， 只保留有限的对外接口使之与外部发生联系。
4） 实例化对象
定义一个类的对象，通过对象调用类中的成员
3、类的简单设计格式

class 类名{ 
    类的特征（属性） 成员变量 
    类的行为（功能） 成员方法， 函数 
}；
1
2
3
4

比如：设计一个女朋友类

class GirlFriend{
    //属性--数据成员
    char name[256];
    int age;
    float score;
    //行为--函数成员
    void print()
    {
        cout<<name<<age<<score<<endl;
    }
    int playGame()
    {
        cout<<"playGame"<<endl;
    }
    int study()
    {
        cout<<"study"<<endl;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4、结构体与类

5、类的成员权限
成员的性质由关键字public、protected、private 决定 ，如果在进行类的声明时不写上面这些关键字，默认都是私有的。

public     公有         公有段的成员是提供给外部的接口 
protected  保护         保护段成员在该类和它的派生类中可见 
private    私有         私有段成员仅在类中可见 
1
2
3

class  类名
{
public://公共权限        类的外部 类内部   类的派生类  友元

protected://保护权限    类内部   类的派生类  友元

private://私有权限    类内部    友元

};
1
2
3
4
5
6
7
8
9

比如：

//类的实例化，也就是创建一个类的对象
GirlFriend mygirl1;
mygirl1.playGame(); //访问错误，因为类中默认的权限是私有的，不能在类的外部访问私有成员
1
2
3

所以应该给成员添加权限：

//设计一个类
class GirlFriend{
public:
    //行为--函数成员
    void print()
    {
        cout<<name<<age<<score<<endl;
    }
    int playGame()
    {
        cout<<"playGame"<<endl;
    }
    int study()
    {
        cout<<"study"<<endl;
    }
private:
    //属性--数据成员
    char name[256];
    int age = 20;  //C++98标准不支持这种写法 C++11才支持
    float score;    
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

6、如何访问类中的成员

• 类内部的成员访问其它成员，直接访问
• 类的外部 访问类的成员，通过对象才能访问

7、特点
1）类的属性变量成员一般设置为私有权限，可以自己控制属性的读写权限，确保数据的安全性。还可以将用户传入的数据进行检测。

8、类的实例化

1）. 静态分配内存
GirlFriend mygirl1;    
mygirl1.playGame();
1
2
3

9、类的成员内部声明，外部定义

//设计一个类
class GirlFriend{
public:
    //行为--函数成员
    void print();
    int playGame();
    int study()
    {
        cout<<"study"<<endl;
    }
private:
    //属性--数据成员
    char name[256];
    int age = 20;  //C++98标准不支持这种写法 C++11才支持
    float score;    
};
//在类的外部进行定义
void GirlFriend::print()
{
     cout<<name<<age<<score<<endl;
}
int GirlFriend::playGame()
{
     cout<<"playGame"<<endl;
}
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