C++:封装

最新推荐文章于 2024-04-22 08:03:19 发布

咩咩要学习

最新推荐文章于 2024-04-22 08:03:19 发布

阅读量468

点赞数

分类专栏： c++ 学习笔记

本文链接：https://blog.csdn.net/weixin_45663220/article/details/112302025

版权

学习笔记同时被 2 个专栏收录

135 篇文章 1 订阅

订阅专栏

c++

120 篇文章 7 订阅

订阅专栏

C++面向对象三大特征：封装，继承，多态。
“万物皆为对象”，对象上有其属性和行为。
eg:人作为对象，属性有姓名，年龄，身高等；行为有吃饭，睡觉，打豆豆等。
车作为对象，属性有轮胎，备胎，方向盘等；行为有载人，放音乐等。
具有相同性质的对象，我们抽象为类，人属于人类，车属于车类。

1.封装
1.1封装的意义

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

练习：
定义一个圆类：

#include <iostream>
using namespace std;
#include <string>
#include<ctime>
#include<math.h>

const double PI = 3.14;

//设计一个圆类，求圆的周长
//公式：2*PI*半径
class Circle{
    //访问权限
    //公共权限
public:

    //属性
    int m_r;

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

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

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

    system("pause");
    return 0;
}

定义一个学生类：

class Student{
    //访问权限
    //公共权限
public:
    //类中的属性和行为  我们统一称为 成员
    //属性 ： 成员属性或成员变量
    string Name;
    int num;
    
    //行为：成员函数或成员方法
    
    void Print()
    {
        cout << "姓名为：" << Name << endl;
        cout << "学号为：" << num << endl;
    }

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

int main() {
 
    Student one;
    //给圆对象 的属性进行赋值
    one.Name = "大头";
    one.num = 123;

    one.Print();

    Student two;
    two.Name = "大桥";
    two.num = 456;
    two.Print();

    Student three;
    three.setName("dididi");
    three.num = 451;
    three.Print();


    system("pause");
    return 0;
}

类在设计时，可以把属性和行为放在不同的权限下，加以控制。
访问权限有三种：

public 公共权限成员类内可以访问类外也可以
protected 保护权限类内可以，类外不可，儿子也可以访问父亲中的保护内容
private 私有权限类内可以，类外不可儿子不可以访问父亲中的私有内容

//访问权限
//public 公共权限
//protected 保护权限
//private 私有权限

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

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

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

public://公共函数，此时运行成功，即类内可以访问,换成protected函数 或private函数，也可以。因为类内可访问。
    void func()
    {
        m_Name = "张三";//公共权限，类内可访问
        m_Car = "拖拉机";//保护权限，类内可访问
        m_Password = 123;//私有权限，类内可访问
    }
};

int main() {
 
    Person p1;

    p1.m_Name = "李四";//公共权限，类外可访问
   // p1.m_Car = "奔驰";//报错，保护权限类外访问不到
   // p1.m_Password = 123;//报错，私有权限类外访问不到

    system("pause");
    return 0;
}

1.2 struct 和class的区别
唯一的区别就是默认的访问权限不同
struct默认权限为公共，即第一个访问说明符之前的成员默认为共有。
class默认权限为私有，即第一个访问说明符之前的成员默认为私有。

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

struct C2
{
    int m_A;//默认公共
};
int main() {
 
    C1 c1;
   // c1.m_A = 100;//报错 class默认权限为私有,不可访问
    C2 c2;
    c2.m_A = 100;//成功 struct默认权限为私有

    system("pause");
    return 0;
}

1.3 将成员属性设置为私有
优点：

优点1：可以自己控制读写权限

class Person
{
public:
    //写姓名 即设置姓名
    void setName(string name)
    {
        Name = name;
    }
    //读姓名 即获取姓名
    string getName()
    {
        return Name;
    }
    //获取年龄 只读
    int getAge()
    {
        Age = 0;//初始化0岁
        return Age;
    }
    //设置情人 只写
    void setLover(string lover)
    {
        Lover = lover;
    }
private:

    //姓名  可读可写
    string Name;
    //年龄  只读
    int Age;
    //情人  只写
    string Lover;
};
int main() {
    Person p;
    p.setName("张三");
    cout <<  p.getName() << endl;
  
    cout << p.getAge() << endl;
    p.setLover("didi");


    system("pause");
    return 0;
}

这里有两个疑惑：

明明已经声明了成员为私有的，为什么还能通过public接口被外界访问到呢？
答：参考了这篇文章，现在的水平看不太懂，但是有一句话：C++中private和proected仅仅是一个访问限定符，它只限定函数和数据不能被“直接”访问，而不担保这些函数和数据会被通过其他方法间接地访问到。
为什么上面代码中成员函数可以定义在成员之前？
答：编译器分为两步处理：首先编译成员的声明，然后才轮到成员函数体。因此，成员函数体可以随意使用类中的其他成员而无需在意这些成员出现的次序。（《C++ Primer》p232）

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

//年龄 可读可写  如果想修改（范围必须在0~150之间）
    //获取年龄
    int getAge()
    {
        
        return Age;
    }

    //设置年龄
    void setAge(int age)
    {
        if (age < 0 || age > 150)
        {
            cout << "你这个妖精！" << endl;
            return;
        }
        Age = age;
    }

 p.setAge(200);

在这里插入图片描述

设计案例：
在这里插入图片描述

#include <iostream>
using namespace std;
#include <string>
#include<ctime>
#include<math.h>

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 + m_L * m_H + m_H * m_W);
    }
    //获取体积
    int calculateV()
    {
        return m_L * m_H * m_W;
    }

//利用成员函数判断 两个立方体是否相等
    bool isSameByClass(Cube &c)//注意这里只传一个参数
    {
        if (m_H == c.getH() && m_W == c.getW() && m_L == c.getL())
        {
            return true;
        }
        else
        {
            return false;
        }
    }
private:
    int m_L;//长
    int m_W;//宽
    int m_H;//高
};

//利用全局函数判断  两个立方体是否相等
bool isSame(Cube &c1,Cube &c2)//这里用了按引用传递
{
    if (c1.getH() == c2.getH() && c1.getW() == c2.getW() && c1.getL() == c2.getL())
    {
        return true;

    }
    else
    {
        return false;
    }
}
int main() {
    
    Cube c1;
    c1.setL(10);
    c1.setH(10);
    c1.setW(10);

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

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

    //利用全局函数判断
    bool ret = isSame(c1, c2);
    if (ret)
    {
        cout << "相等" << endl;
    }
    else
    {
        cout << "不相等" << endl;
    }

    //利用成员函数判断
    ret = c1.isSameByClass(c2);
    if (ret)
    {
        cout << "相等" << endl;
    }
    else
    {
        cout << "不相等" << endl;
    }
    system("pause");
    return 0;
}

在这里插入图片描述

本例题核心一：在类中可以让另一个类作为本类中的成员。

#include <iostream>
using namespace std;
#include <string>
#include<ctime>
#include<math.h>

class Point
{
public:
    void setX(int x)
    {
        m_X = x;
    }
    int getX()
    {
        return m_X;
    }
    void setY(int y)
    {
        m_X = y;
    }
    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 distence = (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 (distence == rDistance)
    {
        cout << "点在圆上" << endl;

    }
    else if (distence < 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);
  
    system("pause");
    return 0;
}

核心二：可以把类拆分到不同文件里。
我们想把两个类分文件编写：头文件中写声明，源文件中写实现。

来把Ponit类拆开：
我们在头文件中添加point.h文件
在这里插入图片描述

同样，在源文件中添加point.cpp：

然后，在头文件中，我们把Point类代码复制过来，并且把成员函数中的实现部分删掉，只留下声明：
在这里插入图片描述
在源文件中，我们再复制一遍代码，删除多余部分：

这样就拆分好了，同样的方法拆分Circle类：

(多行注释快捷键：Ctrl+K+C)
此时在最开始的文件中，只剩下全局函数和main函数了，我们只需要在文件中包含刚才分出去的类的头文件即可：

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


void isInCircle(Circle& c, Point& p)
{
    //计算两点之间距离平方
    int distence = (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 (distence == rDistance)
    {
        cout << "点在圆上" << endl;

    }
    else if (distence < 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);
  
    system("pause");
    return 0;
}

咩咩要学习

关注

0
点赞
踩
5

收藏

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

C++面向对象三大特征：封装，继承，多态。“万物皆为对象”，对象上有其属性和行为。eg:人作为对象，属性有姓名，年龄，身高等；行为有吃饭，睡觉，打豆豆等。车作为对象，属性有轮胎，备胎，方向盘等；行为有载人，放音乐等。具有相同性质的对象，我们抽象为类，人属于人类，车属于车类。1.封装1.1封装的意义将属性和行为作为一个整体，表现在生活中的事物中将属性和行为加以权限控制练习：定义一个圆类：#include <iostream>using namespace std;#i
复制链接

扫一扫