类的封装

一、类。
1、C++面向对象的三大特性？
封装、继承、多态。

2、C++认为万事万物皆为对象，对象上有其属性与行为。
例如：
人可以作为对象，属性有姓名、年龄、身高、体重...，行为有走、跑、跳。吃饭、唱歌..。
车也可以作为对象，属性有轮胎、方向盘。车灯...，行为有载人、放音乐、放空调...。
具有相同性质的对象，我们可以抽象成为类，人属于人类，车属于车类。

二、封装。
1、封装的意义。
封装是C++面向对象的三大特性之一。
其意义是：
1）将属性和行为作为一个整体，表现生活中的事物。
2）将属性与行为加以权限控制。

2、封装意义一。
在设计类的时候，属性与行为写在一起，表现事物。
语法：
class 类名{
访问权限:
    属性/行为
};

   案例1  ---  设计一个圆类，求圆的周长。

#include <iostream>
using namespace std;

//圆周率
const double PI = 3.14;

//设计一个圆类，求圆的周长。
//圆求周长公式:  2*PI*半径

/*
语法：
class 类名{
访问权限:
    属性/行为
};
*/

class Circle{
public:  //访问权限： 公共权限
    //属性
    //半径
    int m_r;

    //行为
    //获取圆的周长
    double calculateZC()
    {
        return 2 * PI * m_r;
    }
};

int main()
{
    //通过圆类，创建具体的圆(对象)
    //1. 实例化(通过一个类，创建一个对象的过程)
    Circle c1;

    //2. 给圆对象的属性进行赋值
    c1.m_r = 10;

    //3. 对象通过调用类中的行为来求出周长。
    //2*PI*10=62.8
    cout << "圆的周长:" << c1.calculateZC() << endl;

    return 0;
}

   练习1：设计一个学生类，属性有姓名与学号，行为可以给姓名和学号赋值，可以显示学生的姓名和学号。

#include <iostream>
using namespace std;

//设计一个学生类
class Student{
public:
    //类中的属性与行为，我们统一成为成员。
    //属性： 成员属性 / 成员变量
    //行为： 成员函数 / 成员方法

    //属性
    //属性有姓名与学号
    string m_Name; //姓名
    int m_Id;  //学号

    //行为
    //显示姓名与学号
    void showStudent()
    {
        cout << "姓名: " << m_Name << " 学号: " << m_Id << endl;
    }

    //给姓名赋值
    void setName(string name)
    {
        m_Name = name;
    }

    //给学号赋值
    void setId(int id)
    {
        m_Id = id;
    }
};

int main()
{
    //通过学生类，创建具体的学生。
    Student s1;

    //给s1的对象进行属性赋值操作
    s1.setName("张三");
    s1.setId(1);

    //显示学生的信息
    s1.showStudent();

    //再创建一个学生
    Student s2;
    s2.m_Name = "李四";
    s2.m_Id = 2;

    s2.showStudent();

    return 0;
}

3、封装意义二。
类在设计时候，可以把属性和行为放在不同的权限下，加以控制。
访问权限有三种：
1）public     公共权限    类内可以访问，类外可以访问。
2）protected  保护权限    类内可以访问，类外不可以访问。 儿子可以访问父亲中的保护内容。
3）private    私有权限    类内可以访问，类外不可以访问。 儿子不可以访问父亲中的私有内容。

#include <iostream>
using namespace std;

/*
访问权限有三种：
1）public     公共权限    类内可以访问，类外可以访问。
2）protected  保护权限    类内可以访问，类外不可以访问。 
3）private    私有权限    类内可以访问，类外不可以访问。
*/

class Person{
public:
    //公共权限
    string m_Name;  //姓名

protected:
    //保护权限
    string m_Car;  //汽车

private:
    //私有权限
    int m_Password; //银行卡密码

public:
    void func()
    {
        m_Name = "张三";  //公共权限属性类内访问
        m_Car = "拖拉机"; //保护权限属性类内访问
        m_Password = 123456;  //私有权限属性类内访问
    }
};

int main()
{
    //实例化对象
    Person p1;
    p1.m_Name = "李四";  //公共权限属性类外访问
    //p1.m_Car = "奔驰"; //保护权限属性类外访问     -> 不可访问
    //p1.m_Password = 123;  //私有权限属性类外访问  -> 不可访问

    p1.func();

    return 0;
}

三、struct和class的区别？
在C++中struct和class唯一的区别就是在于默认的访问权限不同。
区别：
struct 默认权限为公共。
class  默认权限为私有。

#include <iostream>
using namespace std;

/*
struct 默认权限为公共。
class  默认权限为私有。
*/

class C1{
    int m_A;  //默认的权限就是私有权限。
};

struct C2{
    int m_A;  //默认的权限就是公共权限。
};

int main()
{
    //C1 c1;
    //c1.m_A = 10; //  error: ‘int C1::m_A’ is private
                   //  类默认的属性就是私有的。

    C2 c2;
    c2.m_A = 100; //默认的权限就是公共权限，在类外可以访问。

    return 0;
}

四、成员属性设置为私有。
优点1：将所有成员属性设置为私有，可以自己控制读写权限。
优点2：对于读写权限，我们可以检测数据的有效性。

#include <iostream>
using namespace std;

/*
优点1：将所有成员属性设置为私有，可以自己控制读写权限。
优点2：对于读写权限，我们可以检测数据的有效性。
*/

//设计人类
class Person{
public:
    //设置姓名
    void setName(string name)
    {
        m_Name = name;
    }

    //获取姓名
    string getName()
    {
        return m_Name;
    }

    //设置年龄
    void setAge(int age)
    {
        if(age < 0 || age > 150)
        {
            cout << "年龄有问题喔!" << endl;
            return;
        }
        m_Age = age;
    }

    //获取年龄
    int getAge()
    {
        //m_Age = 0;
        return m_Age;
    }

    //设置情人
    void setLover(string lover)
    {
        m_Lover = lover;
    }

private:
    //姓名:  可读可写
    string m_Name;

    //年龄:  可读可写
    int m_Age;

    //情人:  只写
    string m_Lover;
};

int main()
{
    Person p1;
    //p1.m_Name = "张三";  //写姓名
    p1.setName("张三");

    //cout << "姓名:" << p1.m_Name << endl;
    cout << "姓名: " << p1.getName() << endl;

    p1.setAge(18);
    cout << "年龄: " << p1.getAge() << endl;

    p1.setLover("关国源");

    //无论用哪种办法，都无法访问到情人是谁。
    //cout << "情人: " << p1.m_Lover << endl;
    //cout << "情人: " << p1.getLover() << endl;
}
 
  案例2：  设计立方体类。

设计立方体类(Cube)
求出立方体的面积以及体积。
分别使用全局函数与成员函数判断两个立方体是否相等？
（判断两个立方体相等的条件是长等于长，宽等于宽，高等于高）

思路分析：
class Cube{
public:
    //行为：
    //设置和获取长宽高
    //获取立方体的面积。
    //获取立方体的体积。

private:
    //属性：
    m_L;  -> 长
    m_H;  -> 高
    m_W;  -> 宽
};

#include <iostream>
using namespace std;

//立方体设计
//1. 创建立方体类
//2. 设置属性
//3. 设置行为  获取立方体的面积以及体积
//4. 分别使用全局函数和成员函数 判断两个立方体是否相等

class Cube{
public:
    //设置长
    void setL(int l)
    {
        m_L = l;
    }

    //获取长
    int getL()
    {
        return m_L;
    }

    //设置宽
    void setW(int w)
    {
        m_W = w;
    }

    //获取宽
    int getW()
    {
        return m_W;
    }

    //设置高
    void setH(int h)
    {
        m_H = h;
    }

    //获取高
    int getH()
    {
        return m_H;
    }

    //获取立方体的面积
    int calculateS()
    {
        return 2*m_L*m_W + 2*m_L*m_H + 2*m_W*m_H;
    }

    //获取立方体的体积
    int calculateV()
    {
        return m_L * m_W * m_H;
    }

    //利用成员函数来判断两个立方体是否相等
    bool isSameByClass(Cube &c)
    {
        if(m_L == c.getL() && m_W == c.getW() && m_H == c.getH())
        {
            return true;
        }
        return false;
    }

private:
    int m_L;  //长
    int m_H;  //高
    int m_W;  //宽
};

//使用全局函数来判断两个立方体是否相等
bool isSame(Cube &c1,Cube &c2)
{
    if(c1.getL() == c2.getL() && c1.getW() == c2.getW() && c1.getH() == c2.getH())
    {
        return true;
    }

    return false;
}

int main()
{
    //创建立方体对象
    Cube c1;
    c1.setL(10);
    c1.setW(10);
    c1.setH(10);

    cout << "c1的面积为:" << c1.calculateS() << endl;
    cout << "c1的体积为:" << c1.calculateV() << endl;

    Cube c2;
    c2.setL(10);
    c2.setW(10);
    c2.setH(9);

    bool ret = isSame(c1,c2);
    if(ret)
    {
        cout << "c1与c2是相等的" << endl;
    }
    else{
        cout << "c1与c2是不相等的" << endl;
    }

    ret = c1.isSameByClass(c2);
    if(ret)
    {
        cout << "c1与c2是相等的" << endl;
    }
    else{
        cout << "c1与c2是不相等的" << endl;
    }
}