「地表最强」C++核心编程（四）类和对象--封装

B_White1024

已于 2022-12-31 18:09:54 修改

阅读量378

点赞数

分类专栏： C++ 文章标签： c++ 开发语言

于 2022-12-15 22:41:43 首次发布

本文链接：https://blog.csdn.net/qq_43143724/article/details/128336499

版权

C++ 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

环境：
编译器：CLion2021.3；操作系统：macOS Ventura 13.0.1

文章目录

一、封装的意义
二、struct和class的区别
三、成员属性设置为私有
四、两个封装案例
- 4.1 立方体
- 4.2 点和圆的关系

C++是一门面向对象的语言，他的三大特性分别是封装、继承和多态。对象可以看做是属性和行为的整体。就像人是一个对象，一个人的属性可以有姓名性别学历等，一个人的行为可以有唱，跳，rap和篮球等。把一个人的属性和这些行为整合成一个整体打包起来，就可以描述一个人的特点，这就是封装的作用。

一、封装的意义

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

const double PI = 3.14;
//用半径和求周长的方法封装一个圆类
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;
    return 0;
}

2.将属性和行为加以权限控制
为了安全起见，类中的某些属性或方法不希望被外界访问如密码，而有些属性和方法被外界访问也无所谓。这就需要用不同的访问权限来修饰属性或方法。C++中的权限有以下三种：

/*  访问权限：
 *      public              成员类内类外都可以访问
 *      protected           成员类内可以访问，类外不可以访问    儿子也可以访问父亲中保护的内容
 *      private             成员类内可以访问，类外不可以访问    儿子不可以访问父亲中保护的内容，具体区别在继承中展开
 */
class Person {
public://公共权限
    string mName;
protected://保护权限
    string mCar;
private://私有权限
    int mPassword;

public://这个方法在外可以被访问
    void func1() {
        mName = "zhangsan";
        mCar = "lexus";
        mPassword = 1111;
    }

private://这个方法在外不可以被访问
    void func2() {
        mName = "zhangsan";
        mCar = "lexus";
        mPassword = 1111;
    }
};

int main() {
    Person p1;
    p1.mName = "lisi";//ok，public可以类外访问
//    p1.mCar = "aodi";//err，protected权限在类外不可以访问
//    p1.mPassword = 0000;//err，private权限在类外不可以访问
    p1.func1();//ok
//    p1.func2();//err，private权限在类外不可以访问

    return 0;
}

二、struct和class的区别

不难发现，class和struct在使用的时候很相似。他们唯一的区别在于默认的访问权限不同：struct默认权限是public而class默认权限是private.

class C1
{
    int m_A;//默认是private
};

struct C2
{
    int m_A;//默认是public
};

int main(){
    C1 c1;
//    c1.m_A = 1;//err

    C2 c2;
    c2.m_A = 1;//ok
    return 0;
}

三、成员属性设置为私有

在设计类的时候，一般将成员属性设置为private，然后提供一个public的接口，外界可以通过这个接口来访问成员属性。这里的接口就是对成员属性进行读写操作的函数。

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

 class Person {
private:
    string mName;//可读可写
    int mAge;//可读可写
    
public:
    //给类外提供写姓名的接口
    void setName(string name) {
        mName = name;
    }
    //给类外提供读姓名的接口
    string getName() {
        return mName;
    }


    //给类外提供写年龄的接口，若想让mAge属性只读，不要这个函数即可
    void setAge(int age) {
        if(age<0 || age>200)//可以检测数据的有效性
            return ;
        else
            mAge = age;
    }
    //给类外提供读年龄的接口
    int getAge(){
        return mAge;
    }

};

int main() {
    Person p;
    p.setName("zhangsan");//通过get和set函数来间接操作成员属性
    cout << "name= " << p.getName() << endl;

    p.setAge(10);
    cout << "age= " << p.getAge() << endl;

    return 0;
}

四、两个封装案例

4.1 立方体

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

class Cube {
private:
    int mLength;
    int mWidth;
    int mHigh;
public:
    void setLength(int length) {
        mLength = length;
    }

    int getLength() {
        return mLength;
    }

    void setWidth(int width) {
        mWidth = width;
    }

    int getWidth() {
        return mWidth;
    }

    void setHigh(int high) {
        mHigh = high;
    }

    int getHigh() {
        return mHigh;
    }

    int getArea() {
        return 2 * (mHigh * mWidth + mHigh * mLength + mWidth * mLength);
    }

    int getVol() {
        return mLength * mWidth * mHigh;
    }

    bool isEqualByClass(Cube &cube){//需要对象调用这个函数，因此传递一个参数即可
        if (mHigh == cube.getHigh() && mLength == cube.getLength() && mWidth == cube.getWidth())
            return 1;
        return 0;
    }

};

bool isEqual(Cube &c1, Cube &c2) {//用引用是为了不产生临时的数据
    if (c1.getHigh() == c2.getHigh() && c1.getLength() == c2.getLength() && c1.getWidth() == c2.getWidth())
        return 1;
    return 0;
}

int main() {

    Cube cube;
    cube.setHigh(10);
    cube.setWidth(10);
    cube.setLength(10);

    cout << "面积是：" << cube.getArea() << endl;
    cout << "体积是：" << cube.getVol() << endl;

    Cube cube1;
    cube1.setLength(10);
    cube1.setWidth(10);
    cube1.setHigh(10);

    //通过全局函数判断是否相等
    if(isEqual(cube,cube1))
        cout<<"全局函数判断：相同的立方体"<<endl;
    else
        cout<<"全局函数判断：不同的立方体"<<endl;

    //通过成员函数判断是否相等
    if(cube.isEqualByClass(cube1))
        cout<<"成员函数判断：相同的立方体"<<endl;
    else
        cout<<"成员函数判断：不同的立方体"<<endl;


    return 0;
}

4.2 点和圆的关系


#include "circle.h"
#include "point.h"

//判断点和圆的关系：两点间距离的平方和圆半径的平方相比较，这样方便计算不用开平方。
void Guanxi(Circle c, Point p) {
    int dis = (c.getCtr().getX() - p.getX()) * (c.getCtr().getX() - p.getX()) +
              (c.getCtr().getY() - p.getY()) * (c.getCtr().getY() - p.getY());
    int rdis = c.getR() * c.getR();

    if(dis < rdis){
        cout<<"点在圆内"<<endl;
    }else if(dis > rdis){
        cout<<"点在圆外"<<endl;
    }else{
        cout<<"点在圆上"<<endl;
    }
}

int main() {
    Circle c;
    c.setR(10);
    Point center;
    center.setX(10);
    center.setY(0);
    c.setCtr(center);

    Point p1;
    p1.setX(10);
    p1.setY(8);

    Point p2;
    p2.setX(10);
    p2.setY(10);

    Point p3;
    p3.setX(10);
    p3.setY(11);

    Guanxi(c,p1);//点在圆内
    Guanxi(c,p2);//点在圆外
    Guanxi(c,p3);//点在圆上

    return 0;
}