0基础学C++ | 第13天 | 基础知识 | 类 | 对象

目录

前言

封装 

封装的意义

struct 和 class 的区别

成员属性设置为私有

前言

众所周知， C++是一个面向对象的编程语言（面向对象的C++语言的特点就是：封装、继、 多态），它与面向过程的C语言不通，对面向过程的初级认识就是他强调的是一个过程，这样说是不是还是很空洞，下面举个例子就会好理解很多：

在面向过程中：把大象装进冰箱需要3步：打开冰箱门，把大象放进去，再关上冰箱，强调的是一个求解问的步骤

在面向对象中：把大象和冰箱看作两个对象，然后通过操作两个对象来把大象放到冰箱里。关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

再比如一个选课系统
面向过程：选课、上课  两个过程
面向对象：学生、老师  关注的是两个类对象之间的关系

 在C++中，万事万物皆为对象，对象有属性和行为

例如 ：

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

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

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

封装 

封装的意义

封装是C++面向对象三大特点之一，它的主要意义就是在于将对象的属性和行为作为一个整体，来表现我们的对象，另外就是对属性和行为进行权限的控制 

它的语法是：class 类名{ 访问权限：属性 / 行为 }   （class为定义类的关键字）

下面定义一个圆类，求圆的周长

#include<iostream>
using namespace std;

const double PI = 3.14
//设计一个类
class Circle
{
    //访问权限
    public: //公共权限

    //属性（通常就是一些变量）
    int m_r; //半径

    //行为（通常用函数来获取）
    double calculateZC() //获取圆的周长
    {
        return 2*PI*m_r;
    }
};
 
int main()
{
    //通过圆类 实例化一个具体的圆（对象）
    Circle cl;  // Circle是先前创建的类 cl是具体的圆对象

    //给圆对象的属性进行赋值
    cl.m_r = 10;  //通过  .  来获取属性 并进行赋值
    cout << "圆的周长为："<< cl.calculateZC <<endl;

    system("pause");
    return 0;
}

以上代码就是设计一个圆类class Circle，在这个圆类中，定义了属性半径m_r，以及通过函数double calculateZC创建一个求解圆周长的行为，并且在主函数中通过圆类实例化了一个具体的圆对象 Circle cl来访问我们的类，cl就是我们的是实例化对象，要获取属性，就要使用到“.”点这个符号，通过cl.m_r来获取半径，同时进行赋值，同样，获取周长就是cl.calculate。

那么为加深对类设计的认识，下面再来一个例子：设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号，

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

//设计一个学生类
class Student
{
    //访问权限
    public: //公共权限

    //属性（通常就是一些变量）
    string m_Name; //姓名
    string m_Id; //学号

    //行为（通常用函数来获取）
    void  setName(string name) //获取学生姓名
    {
       m_Name = name;
    }
    void  setId(int id) //获取学生学号
    {
       m_Id = id;
    }
    void  showStudent() //显示学生信息
    {
       cout << "姓名：" << m_Name << "学号：" << m_Id << endl;
    }

    //除了通过在主函数里面复制的方式，还可以用函数在类的行为来进行赋值
    void  setName(string name) //给学生姓名赋值
    {
       m_Name = name;
    }  
    
};
 
int main()
{
    //通过学生类 实例化一个具体的学生（对象）
    Student stu1;  

    //给学生1对象的属性进行赋值
    stu1.m_Name = "张三"; 
    stu1.m_Id = "123456789";
    stu1.showStudent

    //给学生2对象的属性进行赋值
    stu2.m_Name = "李四"; 
    stu2.m_Id = "1234567890";
    stu2.showStudent

    //通过行为对学生姓名进行赋值
    stu1.setName("张三")；

    system("pause");
    return 0;
}

​

 注意：   类中的属性和行为统称为   成员

               属性  也称为  成员属性    或   成员变量

               行为  也称为  成员函数   或   成员方法

 在上面代码中我们发现 每次都会在属性和行为前面进行权限的限制（public），这是因为在设计类时，属性和行为放在不同的权限下，访问权限有三种：public（公共权限）、protected（保护权限）、private（私有权限）。下面一段代码进行详细解释

公共权限	public	类内可以访问	类外可以访问
保护权限	protected	类内可以访问	类外不可以访问 （子类可以访问父类中的保护内容）
私有权限	private	类内可以访问	类外不可以访问（子类不可以访问父类中的私有内容）

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

//设计一个类
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 = "123456"; //此时这里会出现错误 因为银行卡密码这个属性是保私有权限，不能在类外访问

    system("pause");
    return 0;
}​

struct 和 class 的区别

 在C++中struct 和 class 的唯一区别就在于 默认的访问权限不同，struct默认访问权限为公共的，class的默认访问权限为私有的。

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

//设计一个类
class C1
{
    string m_Name;//当我们不定义权限的时候，默认是私有权限
};
//定义一个结构体
struct S1
{
    string m_Name;//当我们不定义权限的时候，默认是共有权限
};

int main()
{
    C1 c1;//不能进行访问，因为class的默认权限是私有的，类的外部不能访问
    S1 s1;//能进行访问，因为struct的默认权限是共有的，类的外部也能访问
    system("pause");
    return 0;
}​​

成员属性设置为私有

通过使用私有成员属性，可以实现类的封装，隐藏内部实现细节，并提供对外部世界的受控访问。这有助于提高代码的模块化程度，减少代码的耦合性，同时也方便了代码的维护和重构。将成员属性设置为私有，有以下优点：

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

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

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

class Person
{
bublic:
    void setName(string name) //写操作
    {
        m_Name = name;
    }

    string getName(string name) //读操作
    {
       return m_Name;
    }
    
     void setAge(int age) //写操作
    {
        m_Age = age;
    }

    string getIdol(string idol) //读操作
    {
        return m_Idol;
    }

private：
    string m_Name;// 可读可写
    int m_Age;    //只写不读
    string m_Idol; //只读不写

};

int main()
{
    Person  p;
    p.setName("张三");//写操作
    cout << " 姓名：" << p.getName() << endl; //读操作

    p.setAge(18);//写操作
    cout << " 年龄：" << p.m_Age<< endl; //读操作,此时会发生错误，因为我们只给了写的权限

    p.m_Idol="se";//写操作,此时会发生错误，因为我们没有给写的权限
    cout << " 年龄：" << p.getIdol()<< endl; //读操作

    system("pause");
    return 0;
}​​

上面这段代码可以看看出来，我们的定义了私有属性：name、age、idol ，私有权限在类外是不能访问的，现在我们想要进行访问，进行读和写操作，于是我们就定个公有权限的读写函数来获取，写就是setxxx(例如setName)，读就是getxxx(例如getName)，对于我们定义的几个属性，我们只想外部写（更改）年龄，但是不想外部读取年龄，此时就只需要定义一个setAge函数来对年龄进行更改，而对于偶像Idol，我们只想外部进行读操作，并不能对它进行写操作（也就是更改Idol的姓名），此时就只需要一个getIdol函数来返回我们偶像名字，并且在主函数中进行打印，这样外界就知道了这个人的idol是谁了，如果又读又写，就两个函数都定义一个，然后在主函数进行调用。以上就是将所有的成员属性设置为私有，可以自己控制读写权限。

对于写权限，我们可以检测数据的有效，可以举个例来说明，就是说 我们在写入年龄的时候，可以进行判断输入的年龄是否符合规定，比如我们在写函数setAge()中添加一个判断语句来设置输入的年龄应该是0到100之间，如果写入的年龄超过100或低于0，那么就是无效的。

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

class Person
{
bublic:
    
     void setAge(int age) //写操作
    {
        if (age < 0 || age > 100)
        {
            cout << "年龄" << age << "输入数字无效，赋值失败！" << endl;
            return;
        }
        m_Age = age;
    }

private：
    string m_Name;// 可读可写
    int m_Age;    //只写不读  （只能在0-100之间）
    string m_Idol; //只读不写

};

int main()
{
    Person  p;
 
    p.setAge(180);//写操作
    cout << " 年龄：" << p.m_Age<< endl; //读操作,此时会发生错误，因为我们只给了写的权限

    system("pause");
    return 0;
}​​