类和对象——封装

师从黑马程序员

封装

封装的意义一

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

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

设计一个圆类，求圆的周长   代码：

示例1：

#include <iostream>
using namespace std;

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

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



int main()
{
   //通过圆类 创建具体的圆（对象）
   Circle c1;
   //给圆对象的属性进行赋值
   c1.m_r=10;

   cout<<"圆的周长为： "<<c1.calculateZC()<<endl;
    return 0;
}

示例2：

设计一个学生类，属性具有姓名和学号，姓名和学号可以赋值，并将其显示

#include <iostream>
using namespace std;

class Student
{
public:
    // 定义构造函数，初始化姓名和学号
    Student(string name, int stuNum)
        : m_name(name), m_stuNum(stuNum) {}

    // 姓名和学号的setter方法
    void setName(string name) { m_name = name; }
    void setStuNum(int stuNum) { m_stuNum = stuNum; }

    // 打印学生信息的方法
    void printStu()
    {
        cout << "学生姓名为：" << m_name << endl;
        cout << "学生学号为：" << m_stuNum << endl;
    }

private:
    string m_name;
    int m_stuNum;
};

int main()
{
    // 创建一个学生对象，并初始化姓名和学号
    Student s1("张三", 123456);

    // 调用打印学生信息的方法
    s1.printStu();

    return 0;
}

封装意义二：

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

访问权限有三种：

1、public   公共权限           成员  类内可以访问  类外可以访问

2、protected 保护权限        成员  类内可以访问  类外不可以访问

3、private  私有权限           成员  类内可以访问  类外不可以访问

#include <iostream>
using namespace std;


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;

class C1
{
    int m_A;
};

struct C2
{
    int m_A;
};

int main()
{
   C1 c1;
  // c1=100;  //在class里默认权限  私有，因此类外不可以访问
  

   C2 c2;
   c2=100;//在class里默认权限  公有，因此可以访问

    return 0;
}

成员属性设置为为私有

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

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

#include <iostream>
#include<string >
using namespace std;


class Person
{
public:
    //设置姓名
    void setName(string name)
    {
        m_Name=name;
    }
    //获取姓名
    string getName()
    {
        return m_Name;
    }
    //获取年龄
    int getAge()
    {
        return m_Age;
    }
    //设置年龄（0~150）
    void setAge(int age)
    {
        if(age<0||age>150)
        {
            cout<<"年龄输入有误，赋值失败"<<endl;
            return ;
        }
        m_Age=age;
    }
     //设置偶像
    void setIdol(string Idol)
    {
        m_Idol=Idol;
    }
private:
    string m_Name; //姓名   可读可写

    int m_Age=18;  //年龄  只读  也可以写0~150

    string m_Idol;//偶像 只写
};
int main()
{
    Person p;

    //姓名设置
    p.setName("张三");
    //姓名获取
    cout<<"姓名： "<<p.getName()<<endl;

    //年龄设置
    p.setAge(160);
    //年龄获取
    cout<<"年龄： "<<p.getAge()<<endl;//只读

    //偶像设置
    p.setIdol("小明");//只写
    return 0;
}

联系案例1：设计立方体类

设计立方体类（Cube）

求出立方体的面积和体积

分别用全局函数和成员函数两个立方图是否相同

#include <iostream>
#include<string>
using namespace std;

class Cube
{
private:
    int m_A;
public:
    // 构造函数初始化边长
    Cube(int A) : m_A(A) {}

    // 设置边长的成员函数
    void setA(int A)
    {
        m_A = A;
    }

    // 获取边长的成员函数
    int getA()
    {
        return m_A;
    }

    // 计算面积的成员函数
    int getArea()
    {
        return m_A * m_A;
    }

    // 计算体积的成员函数
    int getVolume()
    {
        return m_A * m_A * m_A;
    }

    // 成员函数判断当前立方体与另一个立方体是否相同
    bool isSameCube(const Cube& other)
    {
        return m_A == other.m_A;
    }
};

// 全局函数判断两个立方体是否相同
bool areCubesSame(Cube c1, Cube c2)
{
    return c1.getA() == c2.getA();
}

int main()
{
    Cube c1(10);
    Cube c2(5);

    cout << "立方体c1的边长为：" << c1.getA() << endl;
    cout << "立方体c1的面积为：" << c1.getArea() << endl;
    cout << "立方体c1的体积为：" << c1.getVolume() << endl;

    cout << "立方体c2的边长为：" << c2.getA() << endl;
    cout << "立方体c2的面积为：" << c2.getArea() << endl;
    cout << "立方体c2的体积为：" << c2.getVolume() << endl;

    // 使用成员函数判断是否相同
    cout << "成员函数判断：c1和c2是否相同？" << (c1.isSameCube(c2) ? "是" : "否") << endl;

    // 使用全局函数判断是否相同
    cout << "全局函数判断：c1和c2是否相同？" << (areCubesSame(c1, c2) ? "是" : "否") << endl;

    return 0;
}

联系案例2：点和圆的关系

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

#include <iostream>
using namespace std;
//点类
class Point
{
public:
    //设置X
    void setX(int x)
    {
        m_X=x;
    }
    //获取X
    int getX()
    {
        return m_X;
    }
    //设置Y
    void setY(int y)
    {
        m_Y=y;
    }
    //获取X
    int getY()
    {
        return m_Y;
    }

private :
    int m_X;
    int m_Y;
};
//圆类
class Circle
{
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;
    }
private :
    int m_R;//半径

    //在类中可以让另一个类 作为本来中的成员
    Point m_Center;//圆心
};
//判断电和圆的关系
void isInCircle(Circle &c,Point &p)
{
    //两点间距离的平方
    int distance=
    (c.getCenter().getX()-p.getX())*(c.getCenter().getX()-p.getX())
   +(c.getCenter().getY()-p.getY())*(c.getCenter().getY()-p.getY());
    //半径的平方
    int rDistance=c.getR()*c.getR();
    //判断关系
    if (distance==rDistance)
    {
        cout<<"点在圆上"<<endl;
    }
    else if(distance>rDistance)
    {
        cout<<"点在圆外"<<endl;
    }
    else
    {
        cout<<"点在圆内"<<endl;
    }
}
int main()
{
    //创建圆
    Circle c;
    c.setR(10);
    Point center;
    center.setX(10);
    center.setY(0);
    c.setCenter(center);
    //创建点
    Point p;
    p.setX(10);
    p.setY(10);

    //判断关系
    isInCircle(c,p);

     return 0;
}

 若有侵权，请联系作者