类与对象 ——封装——类（class)

类和对象

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

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

例如：

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

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

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

 

4.1 封装

4.1.1 封装的意义

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

封装的意义：

• 将属性和行为作为一个整体，表现生活中的事物
• 将属性和行为加以权限控制

封装意义一：

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

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

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

#include <iostream>
using namespace std;
const double pi = 3.14;
class yuan
{
    //访问权限
    //公共权限
public:
    //属性
    //半径
    int r;
    //行为
    //获取圆的周长
    double calculate()
    {
        return 2 * pi * r;
    }
};
int main()
{
    yuan yuan1;//通过圆类，创建圆的对象,实例化 （通过一个类 创建一个对象）

cout << "请输入圆的半径" << endl; 
cin >> yuan1.r ; 
cout << "半径为" << yuan1.r << "的圆面积为 ：" <<yuan1.calculate(); 
return 0; 
}

 学生类

// **示例2：**设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
#include <iostream>
#include <string.h>
using namespace std;
class student
{
// 类中的属性与行为 我们统一称为 成员
// 属性 成员属性 成员变量
// 行为 成员函数 成员方法
//属性
public:
    string NAME;
    int ID;
//行为
    void showStudent(string name,int id)
    {
        cout << "学生姓名为：" << name << endl
        << "学生学号为：" << id << endl;
    }
};
int main()
{
    class student stu;
    cout << "please enter the student name :" << endl;
    cin >> stu.NAME;
    string name = stu.NAME;
    cout << "please enter the student ID :" << endl;
    cin >> stu.ID;
    int id = stu.ID;
    stu.showStudent(name,id);
}

 

 

封装意义与三种权限：

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

访问权限有三种：

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;
}

 

 

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;
}

成员属性设置为私有

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

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

#include <iostream>
#include <string>
using namespace std;
class student
{
private:
    string name;
    int age;
    string lover;
public:
    void sname(string tname)//可写
    {
        name = tname;
    }
    string getname()//可读（被使用者读到）
    {
        return name;
    }
    int ag(int a)//可写又可读（被使用者读到）
    {
        age = a;
        if (age < 0 || age > 150)
        {
            cout << "请输入0~150之间的数值" << endl;
            return 0;
        }
        return age;
    }
    void slover(string slove)//只写（只可以写入，不可以被外界读到）
    {
        lover = slove;
    }
};
int main(void)
{
    student student1;
    student1.sname("二狗");
    cout << student1.getname() << endl;
    cout << student1.ag(18) << endl;
}

 

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

设计立方体类(Cube)

求出立方体的面积和体积

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

#include <iostream>
#include <string>
using namespace std;
class Cube
{
private :
    int m_l;
    int m_w;
    int m_h;
public :
    void volumn(int l, int w, int h)
    {
        m_l = l ;
        m_w = w;
        m_h = h;
    }
    int ivolumn()
    {
        return  m_l * m_w * m_h;
    }
    void area(int l, int w, int h)
    {
        m_l = l;
        m_w = w;
        m_h = h;
    }
    int iarea()
    {
        return  2 * (m_l * m_w + m_l * m_h + m_w * m_h);
    }
    string compare1(Cube& c)//成员函数中的判断
    {
        if ((m_l * m_w * m_h) == c.ivolumn() && (2 * (m_l * m_w + m_l * m_h + m_w * m_h) )== c.iarea())
        {
            return "两个多边形完全相同";
        }
        return "两个多边形不完全相同";
    }
};
// 全局函数中的判断
string compare(Cube &cube1, Cube &cube2)
{
    if (cube1.ivolumn() == cube2.ivolumn() && cube1.iarea() == cube2.iarea())
    {
        return "两个多边形完全相同";
    }
    return "两个多边形不完全相同";
}
int main()
{
   Cube cube1;
   cube1.volumn(4, 3, 5);
   cube1.area(4, 3, 5);
   cout << "cube1's volumn :" << cube1.ivolumn() << endl;
   cout << "cube1's area :"<<cube1.iarea() << endl;
   Cube cube2;
   cube2.volumn(4, 3, 5);
   cube2.area(4, 3, 5);
   cout << "cube2's volumn :" << cube2.ivolumn() << endl;
   cout << "cube2's area :" << cube2.iarea() << endl;
   cout << "全局函数中的判断：" << compare(cube1, cube2) << endl;
   cout << "成员函数中的判断：" << cube1.compare1(cube2) << endl;
   return 0;
}

 

练习案例2：点和圆的关系

设计一个圆形类（Circle），和一个点类（Point），计算点和圆的关系。

 

 函数主体

#include <iostream>
#include "point.h";
#include "circle.h"
#include "isincircle.h"
#include "ssincircle.h"
using namespace std;
// 点类
//class point
//{
//private:
//    int m_x;
//    int m_y;
//public:
//    void setx(int x)
//    {
//        m_x = x;
//    }
//    int getx()
//    {
//        return m_x;
//    }
//    void sety(int y)
//    {
//        m_y = y;
//    }
//    int gety()
//    {
//        return m_y;
//    }
//};
//圆类
//class Circle
//{
//private:
//    int m_R;
//    point m_Center;
//public:
//    void setR(int r)
//    {
//        m_R = r;
//    }
//    int getR()
//    {
//        return m_R;
//    }
//    void setcenter(point center)
//    {
//        m_Center = center;
//    }
//    // 让另一个类作为本类中的成员
//    point getcenter()
//    {
//        return m_Center;
//    }
//};
//获取和判断圆心到点距离函数
//string isincircle(Circle& c, point& p)
//{
//    if (((c.getcenter().getx() - p.getx()) ^ 2 + (c.getcenter().gety() - p.gety()) ^ 2 )< c.getR())
//    {
//        return "点在圆内";
//    }
//    if (((c.getcenter().getx() - p.getx()) ^ 2 + (c.getcenter().gety() - p.gety()) ^ 2) == c.getR())
//    {
//        return "点在圆上";
//    }
//    return "点在圆外";
//}
//int ssincircle(Circle& c, point& p)
//{
//    return((c.getcenter().getx() - p.getx()) ^ 2 + (c.getcenter().gety() - p.gety()) ^ 2);
//}
int main()
{
    Circle c;
    point p;
    c.getcenter().setx(5);
    c.getcenter().sety(5);
    c.setR(3);
    p.setx(2);
    p.sety(2);
    cout << "圆的半径为 ：" << c.getR() << endl;
    cout << "圆心到点的距离为 ：" << ssincircle(c, p) <<  endl;
    cout << "所以点和圆的关系为 :" << isincircle(c, p);
}

点类分文件编写

point.h

#pragma once //防止头文件重复包含
#include <iostream>
using namespace std;
class point
{
private:
    int m_x;
    int m_y;
public:
    void setx(int x);

    int getx();

    void sety(int y);

    int gety();
}; 

point.cpp

#include "point.h"
void point::setx(int x)
{
    m_x = x;
}
int point::getx()
{
    return m_x;
}
void point::sety(int y)
{
    m_y = y;
}
int point::gety()
{
    return m_y;
}

圆类分文件编写 

circle.h

#pragma once
#include <iostream>
#include  "point.h"
using namespace std;
class Circle
{
private:
    int m_R;
    point m_Center;
public:
    void setR(int r);
    
    int getR();
    
    void setcenter(point center);
    
    // 让另一个类作为本类中的成员
    point getcenter();
    
};

circle.cpp

#include "circle.h"
void Circle :: setR(int r)
{
    m_R = r;
}
int Circle :: getR()
{
    return m_R;
}
void Circle :: setcenter(point center)
{
    m_Center = center;
}
// 让另一个类作为本类中的成员
point Circle :: getcenter()
{
    return m_Center;
}

获取和判断圆心到点距离函数

isincircle.h

#pragma once
#include <iostream>
#include "point.h";
#include "circle.h"
using namespace std;
string isincircle(Circle& c, point& p);

isincircle.cpp

#include "isincircle.h"
string isincircle(Circle& c, point& p)
{
    if (((c.getcenter().getx() - p.getx()) ^ 2 + (c.getcenter().gety() - p.gety()) ^ 2) < c.getR())
    {
        return "点在圆内";
    }
    if (((c.getcenter().getx() - p.getx()) ^ 2 + (c.getcenter().gety() - p.gety()) ^ 2) == c.getR())
    {
        return "点在圆上";
    }
    return "点在圆外";
}

ssincircle.h

#pragma once
#include <iostream>
#include "point.h";
#include "circle.h"
using namespace std;
int ssincircle(Circle& c, point& p);

ssincircle.cpp

include "ssincircle.h"
int ssincircle(Circle& c, point& p)
{
    return((c.getcenter().getx() - p.getx()) ^ 2 + (c.getcenter().gety() - p.gety()) ^ 2);
}