4类和对象

c++面向对象的三大特性：封装、继承、多态

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

例如：

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

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

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

4.1封装

4.1.1封装的意义

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

封装的意义：

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

• 将属性和行为加以权限控制

封装意义一:

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

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

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

示例代码：

#include<iostream>
using namespace std;
const double PI=3.14;
//设计一个圆类，求圆的周长
//圆求周长的公式：2*pi*半径
//class 代表设计一个类，类后面紧跟着的是类名称
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;
}

1.0

#include<iostream>
using namespace std;
#include<string>
//设计一个学生类，显示学生的姓名和学号
class  student
{
public:
    //属性
    //姓名
    string name;
    //学号
    string num;
    //行为
    //给学生的姓名和学号赋值
    string getStudentNum()
    {
        
        return num;
    }
    string getStudentName()
    {
​
        return name;
    }
};
int main()
{
    //通过学生类 创建具体的学生（对象）
    //实例化 （通过一个类 创建一个对象的过程）
    student s1;
    //给人对象的属性赋值
    s1.name = "小明";
    s1.num = "1914080903117";
    cout << "学生的姓名为" << s1.getStudentName() << "\t"<<"学生的学号为" <<s1.getStudentNum()<< endl;
    system("pause");
    return 0;
}

效果如图

2.0

#include<iostream>
using namespace std;
#include<string>
//设计一个学生类，属性有学生的姓名和学号
//可以给姓名和学号赋值，可以显示学生的姓名和学号
//设计学生类
class  Student
{
public://公共权限
    //类中的属性和行为  我们统一称为成员
    //属性 成员属性 成员变量
    //姓名
    string m_Name;
    //学号
    int m_Id;
    //行为 成员函数 成员方法
    //显示姓名和学号的函数
    void showStudent()
    {
        cout<<"姓名："<<m_Name<<"学号： "<<m_Id<<endl;
    }
    //给姓名赋值
    void setName(string name)
    {
     m_Name=name;
    }
     void setId(int id)
    {
     m_Id=id;
    }
};
int main()
{
    //通过学生类 创建具体的学生（对象）
    //实例化 （通过一个类 创建一个对象的过程）
    Student s1;
    //给s1对象的属性赋值
    s1.m_Name = "小明";
    s1.m_Id = 1;
    s1.showStudent();
    Student s2;
    s2.m_Name="李四";
    s2.m_Id=2;
    s2.showStudent();
    s3.setName("张三");
    s3.setId(3)
    s3.showStudent();
    system("pause");
    return 0;
}
效果如图
​

封装意义二：

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

访问权限有三种：

1. public 公共权限

2. protected 保护权限

3. private 私有权限

#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";
        
    }
};
int main()
{
    //实例化具体的对象
    Person p1;
    p1.m_Name="李四";
    //p1.m_Car="奔驰";//保护权限内容，在类外访问不到
    //p1.m_Password="456789";//私有权限内容，类外访问不到
    
    
    system("pause");
    return 0;
}

4.1.2struct和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 默认权限为公共
// class 默认权限为私有
    C1 c1;
    //c1.m_A=100;//false 在class里默认权限为私有，因此类外不可以访问
    C2 c2;
    c2.m_A=100;//在struct 默认权限为公共，因此可以访问
    system("pause");
    return 0;
}

4.1.3成员属性设置为私有

优点1:将所有成员属性设置为私有，可以控制读写功能

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

示例：

#include<iostream>
using namespace std;
#include<string>
//成员属性设置为私有 
//1、可以自己控制读写权限
//2、对于写可以检测数据的有效性
//设计人类
class Person
{
    public:
    //设置姓名
    void setName(string name)
    {
        m_Name = name;
    }
    //获取姓名
    string getName()
    {
        return m_Name;
    }
    //获取年龄
    int getAge()
    {
        m_Age= 0;//初始化为0岁
        return m_age;
    }
    //设置年龄
    void setAge(int age)
    {
        if(age<0||age>150)
        {
            m_Age=0;
            cout <<"你这个妖怪"<<endl;
            return;
        }
        m_Age=age;
        
    }
    //设置情人 只写
    void setLover(string lover)
    {
     m_Lover=lover;
    }
    private:
  //姓名      可读可写
    string m_Name;
    //年龄    可读可写
    int m_Age;
    //情人    只写
    string m_Lover;
    
};
int main()
{
    Person p;
    p.setName("张三");
    cout<<"姓名为： "<<p.getName()<<endl;
    //p.m_Age=18;
    //p.setAge(18);//m_Age为只读权限，无法更改
    p.setAge(1000);
    cout<<"年龄为： "<<p.getAge()<<endl;
    //设置情人为幽雅
    p.setLover("悠雅");
    //cout<<"情人为"<<p.getLover()<<endl;/权限为只写，不可访问
    system("pause");
    return 0;
}

效果图

联系案例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 calculateS()
    {
        return 2*m_L*m_W+2*m_H*m_W+2*m_L*m_H;
    }
    //获取立方体的体积
    int calculateV()
    {
        return m_L*m_H*m_W;
    }
    //利用成员函数判断两个立方体是否相等
    bool isSameByClass(Cube &c)
    {
        if(m_L()==c.getL()&&m_H()==c.getH()&&m_W()==c.getW())
    {
        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.getH()==c2.getH()&&c1.getW()==c2.getW())
    {
        return true;
    }
    else 
        return false;
};
int main()
{
    //创建立方体对象
    Cube c1;
    c1.setL(10);
    c1.setW(10);
    c1.setH(10);
    cout<<"c1的面积为："<<c1.calculateS()<<endl;
     cout<<"c1的体积为："<<c1.calculateV()<<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;
    }
    cout<<"c2的面积为："<<c2.calculateS()<<endl;
     cout<<"c2的体积为："<<c2.calculateV()<<endl;
    //利用成员函数判断的结果
    ret = c1.isSameByClass(c2);
    if(ret)
    {
        cout<<"成员函数判断的结果：c1和c2是相等的"<<endl;
    }
    else
    {
        cout<<"成员函数判断的结果：c1和c2是不相等的"<<endl;
    }
    system("pause");
    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;
    }
    //获取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 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(11);
    //判断关系
    isInCircle(c, p);
    system("pause");
    return 0;
}
​

分文件实现

//头文件 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);
    
    //获取y
    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;
}
//获取y
int Point::getY()
{
    return m_Y;
}
​
​
​
​
​
​

//头文件 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;
    }

#include<iostream>
using namespace std;
#include "circle.h"
#include "point.h"
//点和圆关系的案例
//判断点和圆的关系
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(11);
    //判断关系
    isInCircle(c, p);
    system("pause");
    return 0;
}
​效果如图

 欢迎大家与我私信交流~