类与对象初步

柔光的暖阳◎ 2022-07-11 12:10 101阅读 0赞

# 类与对象 #

> 大纲  
> 1. 什么是类，对象  
> 2. 定义一个类  
> 3. 使用类  
> 4. 实现类成员函数  
> 5. 使用类  
> 6. 多文件处理

## 类与对象 ##

以前说到过  
类之于对象，就与类型之于变量有点像  
我们把某一类实体所具有的所有共性整理在一起  
然后就可以用这一些共性抽象出一个类  
然后用这个类，就可以定义其他具有相似性质的对象

### 可能有点抽象？ ###

在下面的例子中，我会以人类为例子尽可能解释清楚  
一个个活生生的人，都是一个个对象  
而我们从这么多个人中，  
找到了人所应当具有的共性  
这共性有两个方面  
1. 人的某些属性(类的数据成员)  
3. 体重？  
4. 年龄？  
4. 颜值？  
5. ……  
2. 人的行为（类的方法成员）  
3. 人会吃饭  
4. 还会学习  
5. 还有运动呢  
6. 整容。。  
6. ……

我们将根据这些共性  
定义一个person类

## 定义一个类 ##

定义类的语法，与定义结构体相似

> 关键字：class

下面我们根据人的共性  
给出一个person类的**不完整**的定义

class person
    {
    private:
        int weight;
        int age;
    public:
        int yanzhi;//颜值
        void eat(int );
        //还有其他的方法，等下再补充
    };

### 区别 ###

从语法上而言  
1. 关键字从结构体的struct变成了class  
2. 多了几个词  
3. private  
4. public

> 提醒  
> 同结构体一样  
> 代码块后面的分号不能漏

### 访问权限控制 ###

多出来的private和public有什么用呢？  
嘿嘿嘿  
private就是不能被被外界轻易知道嘛  
public就是外界能够知道呀  
(后面会继续详细说明)

## 使用类 ##

> 1.  声明对象
> 2.  初始化对象
> 3.  使用对象中的公有方法

### 声明对象 ###

现在类定义好了  
(还不太完整，会继续补充)  
我们先尝试使用一下  
先用类，声明一个叫做jack的人类

person jack;

现在jack就是一个person类的对象了

### 初始化对象 ###

我们可以这样子吗？

jack.weight = 65;
    jack.age = 18;
    jack.yanzhi = 100;

**!!!!!编译都不会通过**

#### 再说访问权限控制 ####

> 在**类的外部**，  
> 只能够访问类定义中的public部分的成员  
> (也就是**公有成员**)  
> 在private部分的**私有成员**  
> 不能够在类的外部访问

因此，在这里，只有一条语句可行  
`jack.yanzhi = 100;`  
(也的确嘛，身高体重年龄什么的  
都是不容易看不出来  
也不能够随便改变的……)

### 使用公有方法成员 ###

既然在类的外部不能够访问私有成员  
我们可以通过公有方法  
在类的内部去设置  
下面类的定义中

class person
    {
    private:
        int weight;
        int age;
    public:
        int yanzhi;//颜值
        void set_weight(int w) { weight = w;}
        void set_age(int a){ age = a;}
        void eat(int );
        //还有其他的方法，等下再补充
    };

这里我在公有方法中，增加了两个函数  
用于设置里面的成员  
函数的定义因为比较短  
也一并放了进去  
然后我们就可以通过成员运算符  
调用公有的方法成员去进行初始化

int main()
    {
        person jack;
        jack.yanzhi = 100;
        jack.set_weight(65);
        jack.set_age(18);
    }

## 实现类成员函数 ##

下面我来继续实现其他的几个人类所具有的行为  
(类成员函数)

class person
    {
    private:
        int weight;
        int age;
    public:
        int yanzhi;//颜值
        void set_weight(int w) { weight = w;}
        void set_age(int a){ age = a;}
        void eat(int );// 吃
        void study(); // 学习
        void sport(); // 运动
        bool face_lift();//整容
        //还有其他的方法，等下再补充
    };

现在我们还有四个函数没有实现  
我们先来实现一个吃的函数

void eat(int w)
    {
        weight += w；
        //吃多少重多少嘛
    }

> 注意！  
> 由于函数的定义不在类的内部  
> 这样的定义是错误的  
> 因为不能够访问类的内部成员  
> 为了进入类的内部  
> **需要使用作用域解析运算符**

//在函数名前使用作用域解析运算符
    void person::eat(int w)
    {
        weight += w；
        //吃多少重多少嘛
    }

同样的道理，我们来实现其他的几个函数

//记得作用域解析运算符
    void person::study()
    {
        weight--；
        //据说沉迷学习日渐消瘦？
    }
    
    void person::sport()
    {
        weight--；
    }

这个整容的函数有点难写  
毕竟不是百分百能够使颜值上升的  
用个rand()产生随机数好了

> rand()产生从0-RAND\_MAX范围的随机数  
> srand()用来指定产生随机数的种子  
> (这里为了方便就不重设种子了，默认以1为种子)

//大概百分之十的整容失败概率
    bool person::face_lift()
    {
        if (rand() % 10 == 2)
        {
            yanzhi = 0;
            return false;
        }
        else 
        {
            yanzhi++;
            return true;
        }
    }

## 来使用类吧 ##

现在已经把类中所有的东西都实现了  
可以在main()中使用了

#include <iostream>
    using namespace std;
    int main()
    {
        person jack;
        jack.yanzhi = 100;
        jack.set_weight(65);
        jack.set_age(18);
    
        jack.stduy();
        jack.eat(2);
        if (jack.face_lift())
            cout << "整容成功";
        else
            cout << "整容失败";
    
    }

调用类的数据成员和类方法的方式  
上面也展示了一下  
不过  
这依旧是一个具有很多缺陷的类  
比如我没有办法查看体重年龄  
这个可以通过自己多定义一个类成员函数来实现  
比如

void person::show()
    {
        cout << "My height is "
             << height << " cm."
             << endl;
        cout << "My age is "
             << age << " years old."
             << endl;
    }

然后我们就可以通过  
`jack.show();`  
来输出他的体重和年龄

## 关于多文件处理 ##

看到这么多的代码，可能还不知道怎么组织吧  
一般而言，会分为3个文件储存

> 1.  头文件.h  
>     一般放类的定义
> 2.  方法文件.cpp  
>     一般放类的方法的实现
> 3.  使用类的文件.cpp  
>     就是main()函数那个文件

需要注意的问题  
1. 头文件使用宏定义防止多次重复包含  
2. 方法文件和main函数的文件  
都需要包含头文件  
`#include "person.h"`

下面我以上面作为例子  
**头文件person.h**

#ifdef PERSON_H
    #define PERSON_H
    class person
    {
    private:
        int weight;
        int age;
    public:
        int yanzhi;//颜值
        void set_weight(int w) { weight = w;}
        void set_age(int a){ age = a;}
        void eat(int );// 吃
        void study(); // 学习
        void sport(); // 运动
        bool face_lift();//整容
        void show();
    };
    #endif 
    //宏定义是用来防止多次包含

**方法文件person.cpp**

#include "person.h"
    #include <iostream>
    using namespace std;
    //在函数名前使用作用域解析运算符
    void person::eat(int w)
    {
        weight += w；
        //吃多少重多少嘛
    }
    void person::study()
    {
        weight--；
        //据说沉迷学习日渐消瘦？
    }
    
    void person::sport()
    {
        weight--；
    }
    
    //大概百分之十的整容失败概率
    bool person::face_lift()
    {
        if (rand() % 10 == 2)
        {
            yanzhi = 0;
            return false;
        }
        else 
        {
            yanzhi++;
            return true;
        }
    }
    
    void person::show()
    {
        cout << "My height is "
             << height << " cm."
             << endl;
        cout << "My age is "
             << age << " years old."
             << endl;
    }

**main**

#include "person.h"
    #include <iostream>
    using namespace std;
    int main()
    {
        person jack;
        jack.yanzhi = 100;
        jack.set_weight(65);
        jack.set_age(18);
    
        jack.stduy();
        jack.eat(2);
        if (jack.face_lift())
            cout << "整容成功";
        else
            cout << "整容失败";
        jack.show();
        return 0;   
    }

当定义好一个类之后  
我们在main里面写的程序就会  
特别简洁  
可读性特别强  
而且类的私有成员不会被随意地不小心地改动  
(数据隐藏是面向对象编程的特点之一)

## 总结注意事项 ##

1.  private与public的区别  
    及访问权限控制
2.  类的成员函数需要使用作用域解析运算符来实现

## 一些拓展 ##

关于类的特殊成员函数

### 关于构造函数 ###

可能你会想能不能够以这样的方式初始化  
`person jack {65,18,100};`  
C++11中列表初始化的语法是通用的  
因此这里是可以用  
前提是定义了**构造函数**  
构造函数是什么？  
是类对象在初始化的时候自动调用的一个函数  
明天写如何定义。

### 关于析构函数 ###

自动变量在过去后会自动销毁  
对象也不例外  
此时就会调用析构函数来销毁自身  
明天再写