C++中的封装

最新推荐文章于 2024-05-05 08:29:20 发布

大模型算法和部署

最新推荐文章于 2024-05-05 08:29:20 发布

阅读量252

点赞数 5

文章标签： c++ 开发语言 c语言

本文链接：https://blog.csdn.net/qq_53795212/article/details/137500900

版权

本文详细介绍了C++中的面向对象编程，重点讲解了封装的概念、封装在类设计中的应用、访问权限的控制、struct与class的区别以及如何通过实例演示类的属性和行为。通过立方体类和点圆关系的实例，展示了面向对象的多态性和继承特性。

摘要由CSDN通过智能技术生成

circle.hcircle.hC++面向对象的三大特性为：封装 | 继承 | 多态

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

例如：

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

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

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

1. 封装

1.1. 封装的意义

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

封装的意义：

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

封装的意义一：

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

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

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

#include<iostream>
using namespace std;

const double PI = 3.1415926;

//设计一个圆类，求圆的周长
//公式：2 * PI * 半径
class Circle
{
    //访问权限
    //公共权限，属性和行为在类内和类外都可以访问
    public:

    //属性，一般为变量
    //半径
    int radius;

    //行为，一般为函数
    //计算圆的周长
    double calculatePerimeter()
    {
        return 2 * PI * radius;
    }
};


int main()
{
    //通过圆类，创建具体的圆（对象）
    //实例化（通过一个类，创建一个属于该类的对象）
    Circle cl;
    //给圆对象的属性赋值
    cl.radius = 10;

    cout << "圆的周长为：" << cl.calculatePerimeter() << endl;

    return 0;
}


输出：
---------------------------------------------------------------------------------
圆的周长为：62.8319

示例2：设计一个学生类，属性有学号和姓名；行为有赋值和显示

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


//学生类
class Student
{
public:  //公共权限

    //类中的属性和行为，统称为 成员
    //属性：成员属性/成员变量
    //行为：成员函数/成员方法

    //属性
    string m_Name;
    int m_Id;

    //行为
    //显示姓名和学号
    void showStudent()
    {
        cout << "学生信息如下：" << endl;
        cout << "姓名：" << m_Name << endl;
        cout << "学号：" << m_Id << endl;
    };

    //赋值姓名和学号
    void addStudent()
    {
        cout << "请输入学生的姓名：" << endl;
        cin >> m_Name;
        cout << "请输入学生的学号" << endl;
        cin >> m_Id;
        cout << "信息添加成功" << endl;
    };


    
};

int main()
{
    int num;
    Student stu;

    while(1)
    {
        cout << "请输入指令编号（1：添加学生信息 2：显示学生信息 3：退出系统）" << endl;
        cin >> num; 

        if (num == 1)
        {
            stu.addStudent();
            continue;
        }
        else if (num == 2)
        {
            stu.showStudent();
            continue;
        }
        else if (num == 3)
        {
            cout << "退出成功！" << endl;
            break;
        }
        else
        {
            cout << "输入错误，请重新输入！" << endl;
            break;
        }
    }

    return 0;
}


输出：
---------------------------------------------------------------------------------
请输入指令编号（1：添加学生信息 2：显示学生信息 3：退出系统）
1
请输入学生的姓名：
张三    
请输入学生的学号
123456
信息添加成功
请输入指令编号（1：添加学生信息 2：显示学生信息 3：退出系统）
2
学生信息如下：
姓名：张三
学号：123456
请输入指令编号（1：添加学生信息 2：显示学生信息 3：退出系统）
3
退出成功！

封装的意义二：

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

访问权限有三种：

public：公共权限
protected：保护权限
private：私有权限

示例3：

#include<iostream>
using namespace std;


//封装的访问权限
//公共权限 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;
    }

private:
    void func_1()
    {
        m_Name = "张三";
        m_car = "比亚迪";
        m_Password = 123456;
    }
};

int main()
{
    Person p1;

    p1.m_Name = "李四";
    // p1.m_car = "兰博基尼";  //保护权限的属性/变量在类外访问不到
    // p1.m_Password = 123456;  //私有权限的属性/变量在类外访问不到
    p1.func();
    // p1.func_1();  //私有权限的方法/行为/函数在类外访问不到

    return 0;
}

1.2. struct和class的区别

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

具体区别如下：

struct 默认权限为公共
class 默认权限为私有

#include<iostream>
using namespace std;

class C1
{
    int m_A;  //默认权限为 私有
};

struct C2
{
    int m_A;  //默认权限为 公共
};

int main()
{
    //struct 和 class 的区别
    //struct 默认权限为 公共 public
    //class 默认权限为 私有 private

    C1 c1;
    //报错，class默认为私有权限，类外不可以访问其中的变量
    // c1.m_A = 100;  
    // cout << c1.m_A << endl;

    C2 c2;
    c2.m_A = 100;
    cout << c2.m_A << endl;

    return 0;
}


输出：
---------------------------------------------------------------------------------
100

1.3. 成员属性设置为私有

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

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

示例：

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

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

//人类
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 << "年龄：" << age << " 输入有误，赋值失败" << endl;
            return;
        }
        else
        {
            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);

    //获取年龄
    p.getAge();
    cout << "年龄：" << p.getAge() << endl;

    //设置偶像
    p.setIdol("赵丽颖");
    // cout << "偶像：" << p.getIdol() << endl;  //只写状态，外界访问不到

    return 0;
}


输出：
---------------------------------------------------------------------------------
姓名：张三
年龄：160 输入有误，赋值失败
年龄：18

1.4. 练习案例

案例1：设计立方体类

设计立方体类（Cube）

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

#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 getArea()
    {
        return 2 * (m_L * m_W  + m_L * m_H + m_W * m_H);
    }
    //获取立方体体积
    int getVolume()
    {
        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;
        }
        else
        {
            return false;
        }
    }

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

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

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

    cout << "c1的面积为：" << c1.getArea() << endl;
    cout << "c1的体积为：" << c1.getVolume() << endl;

    //创建第二个立方体对象
    Cube c2;
    c2.setL(10);
    c2.setW(10);
    c2.setH(10);

    //利用全局函数进行判断
    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;
    }

    return 0;
}

案例2：点和圆的关系

设计一个圆形类，和一个点类，计算点和圆的关系

main.h

#include <iostream>
#include <cmath>
using namespace std;
#include "point.h"
#include "circle.h"

//判断点和圆的关系
void isInCircle(Circle &c, Point &p)
{
    //计算两点之间距离
    int distance = sqrt(pow(c.getCenter().getX() - p.getX(), 2) + pow(c.getCenter().getY() - p.getY(), 2));

    //判断
    if (distance > c.getR())
    {
        cout << "点在圆外" << endl;
    }
    else if (distance == c.getR())
    {
        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;
}

circle.h

#pragma once
#include<iostream>
using namespace std;
#include "point.h"

class Circle
{
public:
    //设置半径
    void setR(int r);

    //获取半径
    int getR();

    //设置圆心
    void setCenter(Point center);

    //获取圆心
    Point getCenter();

private:
    int m_R; //半径

    //在某一类中，可以让另一个类，作为成员变量
    Point m_Center; //圆心
};

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

point.h

#pragma once
#include <iostream>
using namespace std;

class Point
{
public:
    //设置X 
    void setX(int x);

    //获取X
    int getX();

    //设置Y 
    void setY(int y);

    //获取X
    int getY();

private:
    int m_X;
    int m_Y;
};

point.cpp

#include"point.h"

//设置X 
void Point::setX(int x)
{
    m_X = x;
}
//获取X
int Point::getX()
{
    return m_X;
}
//设置Y 
void Point::setY(int y)
{
    m_Y = y;
}
//获取X
int Point::getY()
{
    return m_Y;
}

编译运行

linux环境下编译：

g++ main.cpp circle.h point.h circle.cpp point.cpp -o main

linux环境下运行：

./main

大模型算法和部署

关注

5
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
C++中的封装

circle.hcircle.hC++面向对象的三大特性为：封装 | 继承 | 多态C++认为万事万物皆为对象，对象上有其属性和行为例如：人可以作为对象，属性有姓名/身高/年龄/体重......，行为有走/跑/跳/吃饭/唱歌......车也可以作为对象，属性有轮胎/方向盘/车灯......，行为有载人/放音乐......具有相同性质的对象，我们可以抽象成类，人属于一类，车也属于一类。
复制链接

扫一扫