第十二章 类和对象

C++面向对象的三大特性为：封装、继承、多态

C++认为万事万物都皆为对象，对象上有其属性和行为

例如：

人可以作为对象，属性有姓名、年龄、身高、体重...，行为有走、跑、跳、吃饭、唱歌...

车也可以作为对象，属性有轮胎、方向盘、车灯...,行为有载人、放音乐、放空调...

具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类

一、封装

1、封装的意义

封装是C++面向对象三大特性之一

封装的意义：

• 将属性和行为作为一个整体，表现生活中的事物

• 将属性和行为加以权限控制

封装意义一：

在设计类的时候，属性和行为写在一起，表现事物

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

示例1：设计一个圆类，求圆的周长

示例代码：

 //圆周率
 const double PI = 3.14;
 ​
 //1、封装的意义
 //将属性和行为作为一个整体，用来表现生活中的事物
 ​
 //封装一个圆类，求圆的周长
 //class代表设计一个类，后面跟着的是类名
 class Circle
 {
 public:  //访问权限  公共的权限
 ​
     //属性
     int m_r;//半径
 ​
     //行为
     //获取到圆的周长
     double calculateZC()
     {
         //2 * pi  * r
         //获取圆的周长
         return  2 * PI * m_r;
     }
 };
 ​
 int main() {
 ​
     //通过圆类，创建圆的对象
     // c1就是一个具体的圆
     Circle c1;
     c1.m_r = 10; //给圆对象的半径 进行赋值操作
 ​
     //2 * pi * 10 = = 62.8
     cout << "圆的周长为： " << c1.calculateZC() << endl;
 ​
     system("pause");
 ​
     return 0;
 }

示例2：设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号

示例2代码：  ​

 //学生类
 class Student {
 public:
     void setName(string name) {
         m_name = name;
     }
     void setID(int id) {
         m_id = id;
     }
 ​
     void showStudent() {
         cout << "name:" << m_name << " ID:" << m_id << endl;
     }
 public:
     string m_name;
     int m_id;
 };
 ​
 int main() {
 ​
     Student stu;
     stu.setName("德玛西亚");
     stu.setID(250);
     stu.showStudent();
 ​
     system("pause");
 ​
     return 0;
 }

封装意义二：

类在设计时，可以把属性和行为放在不同的权限下，加以控制

访问权限有三种：

1. public 公共权限

2. protected 保护权限

3. private 私有权限

示例：

 //三种权限
 //公共权限  public     类内可以访问  类外可以访问
 //保护权限  protected  类内可以访问  类外不可以访问
 //私有权限  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 p;
     p.m_Name = "李四";
     //p.m_Car = "奔驰";  //保护权限类外访问不到
     //p.m_Password = 123; //私有权限类外访问不到
 ​
     system("pause");
 ​
     return 0;
 }

2、struct和class区别

在C++中 struct和class唯一的区别就在于 默认的访问权限不同

区别：

• struct 默认权限为公共

• class 默认权限为私有

 class C1
 {
     int  m_A; //默认是私有权限
 };
 ​
 struct C2
 {
     int m_A;  //默认是公共权限
 };
 ​
 int main() {
 ​
     C1 c1;
     c1.m_A = 10; //错误，访问权限是私有
 ​
     C2 c2;
     c2.m_A = 10; //正确，访问权限是公共
 ​
     system("pause");
 ​
     return 0;
 }

3、成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限

优点2：对于写权限，我们可以检测数据的有效性

示例：

 class Person {
 public:
 ​
     //姓名设置可读可写
     void setName(string name) {
         m_Name = name;
     }
     string getName()
     {
         return m_Name;
     }
 ​
 ​
     //获取年龄 
     int getAge() {
         return m_Age;
     }
     //设置年龄
     void setAge(int age) {
         if (age < 0 || age > 150) {
             cout << "你个老妖精!" << endl;
             return;
         }
         m_Age = age;
     }
 ​
     //情人设置为只写
     void setLover(string lover) {
         m_Lover = lover;
     }
 ​
 private:
     string m_Name; //可读可写  姓名
     
     int m_Age; //只读  年龄
 ​
     string m_Lover; //只写  情人
 };
 ​
 ​
 int main() {
 ​
     Person p;
     //姓名设置
     p.setName("张三");
     cout << "姓名： " << p.getName() << endl;
 ​
     //年龄设置
     p.setAge(50);
     cout << "年龄： " << p.getAge() << endl;
 ​
     //情人设置
     p.setLover("苍井");
     //cout << "情人： " << p.m_Lover << endl;  //只写属性，不可以读取
 ​
     system("pause");
 ​
     return 0;
 }

练习案例1：设计立方体类

设计立方体类(Cube)

求出立方体的面积和体积

分别用全局函数和成员函数判断两个立方体是否相等。

                ​​​​​​​        ​​​​​​​        ​​​​​​​        

#include
using namespace std;

class Cube
{
    private:
        int m_l;
        int m_w;
        int m_h;
    public:
        // setter and getter
        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 getPerimeter()
        {
            return 2 * m_l * m_w + 2 * m_l * m_h + 2 * m_w * m_h;
        }

        // 获取体积
        int getVolume()
        {
            return m_l * m_w * m_h;
        }

        // 判断相等
        bool isSame(Cube &c)
        {
            return m_l == c.getL() && m_w == c.getW() && m_h == c.getH();
        }



};
bool isSame(Cube &c1, Cube &c2)
{
    return c1.getL() == c2.getL() && c1.getW() == c2.getW() && c1.getH() == c2.getH();
}
int main()
{
    // Cube c;
    // c.setL(10);
    // c.setW(10);
    // c.setH(10);

    // cout << "立方体周长：" << c.getPerimeter() << endl;
    // cout << "立方体体积：" << c.getVolume() << endl;

    // Cube c1, c2;
    // c1.setL(10);
    // c1.setW(10);
    // c1.setH(10);

    // c2.setL(10);
    // c2.setW(10);
    // c2.setH(10);
    // cout << (isSame(c1, c2) ? "相等":"不相等") << endl;

    Cube c1, c2;
    c1.setL(10);
    c1.setW(130);
    c1.setH(10);

    c2.setL(10);
    c2.setW(10);
    c2.setH(10);
    cout << (c1.isSame(c2) ? "相等":"不相等") << endl;
    return 0;
}