【C++】类和对象-封装

已于 2023-02-01 17:40:32 修改
阅读量290 收藏
点赞数 2
分类专栏： C++ 文章标签： c++
于 2022-07-02 11:03:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuan3215/article/details/125542020
版权

目录

属 性 和 行 为 作 为 整 体

封装的意义

封装意义1

 设 计 学 生 类

 通过实例化对象对属性进行赋值，再使用类的行为

通过行为对属性进行赋值操作

访 问 权 限

struct 和 class 区别

 成 员 属 性 私 有 化

对外设置 public 接口

检测数据的有效性

立 方 体 类

点 和 圆 关 系

 头文件和源文件封装

属 性 和 行 为 作 为 整 体

C++ 面向对象的三大行为：封 装、继 承、多 态

-

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

人作为对象时，属性有 姓名、年龄、身高、体重...，行为有 走、跑、跳...

封装的意义

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

封装意义1

将属性和行为作为一个整体，表现事物

-

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

设计一个圆类，求圆的周长

#include<iostream>
using namespace std;

// 圆周率
const double PI = 3.14;

// class 代表要设计一个类，后紧跟着的就是类的名称(自定义)
class Circle
{
    // 类的具体内容

    // 访问权限
public:

    // 属性 - 变量
    int m_r; // 半径

    // 行为 - 函数
    double calculateCC() // 获取圆的周长
    {
        return 2 * PI * m_r;
    }
};

// 设计一个圆类
int main()
{
    // 通过圆类创建一个具体的圆（对象）
    Circle c1;
    // 给圆对象进行初始化
    c1.m_r = 10; // 半径
    
    cout << "圆的周长:" << c1.calculateCC() << endl;

    system("pause");
    return 0;
}

 设 计 学 生 类

 通过实例化对象对属性进行赋值，再使用类的行为

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

class Student
{
    // 权限
public:

    // 属性
    string m_Name;
    string m_Id;
    int    m_Age;
    string m_Sex;

    // 行为
    void Showstudent()
    {
        cout << "姓名：" << m_Name << endl;
        cout << "学号：" << m_Id   << endl;
        cout << "年龄：" << m_Age  << endl;
        cout << "性别：" << m_Sex  << endl;
    }
};

int main()
{
    // 实例化对象，通过类创建一个具体对象
    Student s1;

    // 类的属性赋值
    s1.m_Name = "李华";
    s1.m_Id   = "2022";
    s1.m_Age  = 19;
    s1.m_Sex  = "男";

    // 类的行为
    s1.Showstudent();

    system("pause");
    return 0;
}

通过行为对属性进行赋值操作

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

class Student
{
    // 权限
public:
    // 属性
    string m_Name;
    string m_Id;
    int    m_Age;
    string m_Sex;
    // 行为
    void Showstudent()
    {
        cout << "姓名：" << m_Name << endl;
        cout << "学号：" << m_Id   << endl;
        cout << "年龄：" << m_Age  << endl;
        cout << "性别：" << m_Sex  << endl << endl;
    }
    // 行为对属性进行操作
    // 给姓名赋值
    void SetName(string name)
    {
        m_Name = name;
    }
    // 给学号赋值
    void SetId(string id)
    {
        m_Id = id;
    }
    // 给年龄赋值
    void SetAge(int age)
    {
        m_Age = age;
    }
    // 给性别赋值
    void SetSex(string sex)
    {
        m_Sex = sex;
    }

    // 集合到一起
    void SetAttribute(string name, string id, int age, string sex)
    {
        m_Name = name;
        m_Id   = id;
        m_Age  = age;
        m_Sex  = sex;
    }
};

int main()
{
    // 实例化对象，通过类创建一个具体对象
    Student s1;
    // 类的赋值
    s1.m_Name = "李华";
    s1.m_Id   = "2022";
    s1.m_Age  = 19;
    s1.m_Sex  = "男";
    // 类的行为
    s1.Showstudent();
     
    Student s2;
    // 类的赋值
    s2.SetName("李四");
    s2.SetId("2021");
    s2.SetAge(20);
    s2.SetSex("男");
    // 类的行为
    s2.Showstudent();


    Student s3;
    // 类的赋值
    s3.SetAttribute("张三", "2020", 18, "男");
    // 类的行为
    s3.Showstudent();

    system("pause");
    return 0;
}

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

-

属性        成员属性  成员变量

-

行为        成员函数  成员方法

访 问 权 限

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

-

访问权限有三种：

  • public         公 共 权 限        成员 类内可以访问，类外可以访问
  • protected   保 护 权 限        成员 类内可以访问，类外不可以访问
  • private        私 有 权 限        成员 类内可以访问，类外不可以访问（更私有）

类内指的是 class 的大括号内

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

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

    // 保护权限
protected:
    string m_Phone; 

    // 私有权限
private:
    string m_Password;

public:
    void func()
    {
        m_Name     = "李华";
        m_Phone    = "HUWEI";
        m_Password = "123456789";
    }
};

试着在主函数中（类外）对 类属性 m_Phone 和 m_Password 进行修改

 发现可选项只有 公共权限 的 m_Name 和 func

强行访问 会报错

error C2248: “Person::m_Phone”: 无法访问 protected 成员(在“Person”类中声明)

private 私有权限也一样在类外无法访问

struct 和 class 区别

在 C++ 中 struct 和 class 唯一的区别在于 默认访问权限不同，struct 是为了兼容 C 的存在，C++ 中尽量使用 class

-

区别：

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

 成 员 属 性 私 有 化

 优点：

  • 将所有成员属性设为私有，可以自己控制读写权力
  • 对于写的权限，可以检测数据的有效性

对外设置 public 接口

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

class Person
{
    // 设置 public 接口
public:
    // 设置姓名（写）
    void SetName(string name)
    {
        m_Name = name;
    }
    // 获取姓名（读）
    string GetName()
    {
        return m_Name;
    }
    // 设置年龄（写）
    void SetAge(int age)
    {
        m_Age = age;
    }
    // 获取性别（读）
    string GetSex()
    {
        return m_Sex;
    }
    // 设为私有权限
private:
    string m_Name;  // 姓名 可读可写
    int    m_Age;   // 年龄 只写
    string m_Sex;   // 性别 只读
};

int main()
{
    Person p1;
    p1.SetAge(10);
    p1.SetName("李华");
    cout << p1.GetName() << endl;
    system("pause");
    return 0;
}

检测数据的有效性

    // 设置年龄（写）
    void SetAge(int age) // 0~150
    {
        if (age < 0 || age > 150)
        {
            cout << "error age" << endl;
            return;
        }
        m_Age = age;
    }

立 方 体 类

设计立方体（Cube）

-

求出立方体的 面积 和 体积

-

分别用全局函数和成员函数判断两个立方体是否相等

#include<iostream>
using namespace std;

class Cube
{
public:
    // 设置高
    void SetH(int H)
    {
        m_H = H;
    }
    // 获取高
    int GetH()
    {
        return m_H;
    }
    // 设置长
    void SetL(int L)
    {
        m_L = L;
    }
    // 获取长
    int GetL()
    {
        return m_L;
    }
    // 设置宽
    void SetW(int W)
    {
        m_W = W;
    }
    // 获取宽
    int GetW()
    {
        return m_W;
    }
    // 计算面积
    int CalculatedArea()
    {
        return m_H * m_L * 2 +
            m_H * m_W * 2 +
            m_W * m_L * 2;
    }
    // 计算体积
    int CalculatedVolume()
    {
        return m_H * m_L * m_W;
    }
    // 判断两个立方体是否相等
    bool IsEqual(Cube &c2) // 为了传入的更简单一点选择引用
    {
        if (m_H == c2.GetH() && m_L == c2.GetL() && m_W == c2.GetW())
            return true;
        else
            return false;
    }
private:
    // 属性
    int m_H; // 高
    int m_L; // 长
    int m_W; // 宽
};

// 全局函数  判断
bool IsSame(Cube& c1, Cube& c2)
{
    if (c1.GetH() == c2.GetH() && c1.GetL() == c2.GetL() && c1.GetW() == c2.GetW())
        return true;
    else
        return false;
}

int main()
{
    // 创建一个立方体
    Cube c1;
    c1.SetH(10);
    c1.SetL(10);
    c1.SetW(10);

    // 创建一个立方体
    Cube c2;
    c2.SetH(10);
    c2.SetL(10);
    c2.SetW(10);
    cout << "立方体的面积：" << c1.CalculatedArea()   << endl;
    cout << "立方体的体积：" << c1.CalculatedVolume() << endl;
    // 利用成员函数
    if (c1.IsEqual(c2))
    {
        cout << "相同" << endl;
    }
    else
    {
        cout << "不同" << endl;
    }
    // 利用全局函数
    if (IsSame(c1, c2))
    {
        cout << "相同" << endl;
    }
    else
    {
        cout << "不同" << endl;
    }
    system("pause");
    return 0;
}

点 和 圆 关 系

设计一个圆形类（Circle），和一个点类（Point），计算点和圆的关系

#include<iostream>
using namespace std;

// 设计一个点的类
class Point
{
public:
    // 设置 m_X
    void SetX(int x)
    {
        m_X = x;
    }
    // 获取 m_X
    int GetX()
    {
        return m_X;
    }
    // 设置 m_Y
    void SetY(int y)
    {
        m_Y = y;
    }
    // 获取 m_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;
    // 实例化点对象
    // 圆的圆心点
    Point pc;
    pc.SetX(0);
    pc.SetY(0);
    // 点
    Point p;
    p.SetX(0);
    p.SetY(10);
    // 设置半径
    c.SetR(10);
    // 设置圆心
    c.SetCenter(pc);
    // 判断
    IsInCircle(c, p);

    system("pause");
    return 0;
}

 头文件和源文件封装

circle.h 头文件

 .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; // 圆的圆心
};

IsInCircle.h 头文件

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

void IsInCircle(Circle& c, Point& p);

Point.h 头文件

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

//声明

// 设计一个点的类
class Point
{
public:
    // 设置 m_X
    void SetX(int x);
    // 获取 m_X
    int GetX();
    // 设置 m_Y
    void SetY(int y);
    // 获取 m_Y
    int GetY();

private:
    int m_X;
    int m_Y;
};

circle.cpp 源文件

.cpp 对声明的函数进行实现

#include"point.h"
#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;
}
// 属性
int m_R; // 半径
Point m_Center; // 圆的圆心

IsInCircle.cpp 头文件

#include"IsInCircle.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;
    }
}

point.cpp 头文件

#include"point.h" // 包含 point 头文件
// 设计一个点的类
// 设置 m_X
void Point::SetX(int x) // 加上作用域 Point::
{
    m_X = x;
}
// 获取 m_X
int Point::GetX()
{
    return m_X;
}
// 设置 m_Y
void Point::SetY(int y)
{
    m_Y = y;
}
// 获取 m_Y
int Point::GetY()
{
    return m_Y;
}

int m_X;
int m_Y;

main.cpp 主函数源文件

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

int main()
{
    // 实例化圆对象
    Circle c;
    // 实例化点对象
    // 圆的圆心点
    Point pc;
    pc.SetX(0);
    pc.SetY(0);
    // 点
    Point p;
    p.SetX(0);
    p.SetY(10);
    // 设置半径
    c.SetR(10);
    // 设置圆心
    c.SetCenter(pc);
    // 判断
    IsInCircle(c, p);

    system("pause");
    return 0;
}
L1099
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 类和对象(上)
12-21
文章目录类与对象的初步认知类的定义类的信息隐蔽及封装性类的对象大小类成员函数的this指针 c语言到c++，必须要先知道的基础知识！请戳下面的文章链接 —————->>>>>点我，开始入门c++ 类与对象的初步认知 C语言...
C++_类和对象
03-30
类是一种复杂的数据类型，它是将不同类型的数据和与这些数据相关的操作封装在一起的集合体。类的结构(也即类的组成)是用来确定一类对象的行为的，而这些行为是通过类的内部数据结构和相关的操作来确定的。这些行为...
C++的类与对象的封装
最新发布
Qianxueban的博客
06-02 254
C++的类与对象是跨入面向对象编程的第一步，其中有三大特性：封装、继承、多态。其中，封装就是将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。其实封装的本质上就是一种管理，让用户更方便使用类。我拿数据结构中的栈来说，下面是在C中栈的结构体，假设定义了一个对象：ST st；我们是通过push，pop等函数来实现对这个对象进行增删查改的操作，但是如果用户写出这样一句代码，你又能如何面对呢？这是可以的吗？
C++杂讲 类 初讲
万里晴空
05-26 203
目录 知识点1【知识点引入】 知识点2【类的初识】 1、封装 2、权限 3、类的定义（定义类型） 4、类的成员函数 类中声明 类外定义 知识点3【Person类的设计】 知识点4【设计立方体类】 知识点5【点Point和圆Circle的关系】 知识点1【知识点引入】 C语言中 数据 和 方法 是独立： //c语言的思想:数据 方法 分开 //人 typedef struct { char name[32]; int age; }Person; //动物
C++类与对象--封装
S_CuRrY666的博客
01-21 347
https://www.bilibili.com/video/BV1et411b73Z?p=99https://www.bilibili.com/video/BV1et411b73Z?p=99 C++面向对象的三大特性为：封装、继承、多态 C++认为万事万物都皆为对象，对象上有其属性和行为 例如： 人可以作为对象，属性有姓名，年龄，身高，体重...行为有走，跑，跳，吃饭，唱歌... 车也可以作为对象，属性有轮胎、方向盘、车灯...行为有载人、放音乐、开空调 ...
C++ 类和对象-封装
Thewei666的博客
05-07 177
C++面向对象的三大特征为：封装、继承、多态 C++认为所有事物都能成为对象，对象上有其属性和行为 例如：人可以作为对象，属性有姓名、年龄、身高...行为有走、跑、跳... 车可以作为对象，属性有轮胎、车灯，方向盘...行为有载人、放音乐... 封装-属性和行为作为整体 封装是C++面向对象三大特征之一 封装的意义： 将属性和行为作为一个整体，表现生活中的事物 将属性和行为加以权限控制 语法：class 类名{ 访问权限： 属性 / 行为 }； 封装意义一：将属性和行为作为一个整体，表现生
c++类和对象--封装--属性和行为做整体
Courage_D的博客
01-26 1158
封装的意义 1.将属性和行为当做一个整体来表现对象 类中的属性和行为统称为成员: 属性又叫成员属性或成员变量 行为又叫成员函数或成员方法 //案例:设计一个圆类,求圆的周长 #include<iostream> using namespace std; const double PI = 3.14; class circle//设计一个类,class是创建类的关键词,class后加类的名称 { //访问权限 //公共权限:在类内和类外都可以访问 public: /
C++内核对象封装单实例启动程序的类
09-04
主要介绍了利用C++内核对象封装的类，程序只能运行单个实例，可防止多次启动，大家参考使用吧
c++类和对象练习题.doc
10-20
"c++类和对象练习题.doc" 以下是c++类和对象相关知识点的详细解释： ### 1. 类和对象的概念和定义方法 在C++中，类是用户自定义的数据类型，用于描述对象的特征和行为。类是抽象的，不能直接创建对象，而是通过类...
C++类和对象--封装，类分文件编写
周周的博客
12-11 1011
【代码】C++类和对象--封装。
c++基础 面向对象：第四篇 （类和对象-封装）
呋喃吖的博客
06-20 219
类和对象 c++面向对象的三大特性：封装，继承，多态。 在c++中，认为万物皆对象，对象有属性和行为。 在c++中，用关键字 class 去封装对象。 语法： class 类名 { //1.属性 //2.行为 } 属性我们又叫成员变量，成员属性。 行为我们又叫成员函数，成员方法。叫法不同但是都是一个意思。 创建一个对象又叫实例化对象。 由于 class定义出来的对象并不是一个对象，是千千万万个相同属性和行为方法的对象，所以我们抽象出来这个类名，用类名去创建一个具体的对象。 看一个例子感受以下类
C++核心：类和对象之封装（意义、和struct区别、成员属性设为私有、两个封装案例）
m0_74101869的博客
02-06 130
封装的意义、struct和class的区别、成员属性设置为私有、设计立方体类、点和圆的关系
C++类对象的赋值操作
LC的专栏
06-11 9537
学习C语言结构体的时候，结构体定义的变量可以相互赋值，有如下的测试例子： 程序的运行结果如下：
C++类与对象——封装
qq_58619891的博客
11-12 843
C++l类与对象，class与struct的区别，点和圆的关系，判断两个立方体是否相等，成员函数和全局函数的创建于应用，类属性的私有化的优点，肝了一万多字，绝对细致
【C++笔记】封装的意义，结构体和类的区别
Huffie博客
03-05 679
封装的意义将属性和行为作为一个整体，表现生活中的事物；将属性和行为加以权限控制。设计类时，属性和行为写在一起，表现事物，语法规范如下
C语言int r(int m),INT(M)表示什么意思？
weixin_39960019的博客
05-24 1073
根据官方文档描述，int(M)中的M表示数据显示的宽度，与实际存储的长度无关。1、也就是int(3)和int(11)能够存储的数据是一样的，都是从-2147483648到2147483647(或者0-4294967295)。2、int(M)只有联合zerofill参数才能有意义，否则int(3)和int(11)没有任何区别。下面用实例来证明上述两句话：1、创建测试表，具有int(3)、int(11...
C++学习笔记11--类和对象1--封装
温故知新
06-23 158
类和对象封装封装的意义 C++面向对象的三大特性为：封装、继承、多态 C++认为万事万物都皆为对象，对象上有其属性和行为 例如： 人可以作为对象，属性有姓名、年龄、身高、体重… 行为有走、跑、跳、吃饭、唱歌… 车也可以作为对象，属性有轮胎、方向盘、车灯… 行为有载人、 放音乐、放空调… 具有相同性质的对象，我们可以抽象称为类，人属于人类,车属于车类 封装 封装的意义 封装是C++面向对象三大特性之一 封装的意义： 将属性和行为作为一个整体，表现生活中的事物 将属性和行为加以权限控制 封装意义一： 在设计
C++ 类和对象(一、封装)
weixin_45331809的博客
03-02 158
C++面向对象的三大特征为：封装、继承、多态 封装 类和对象 class Circle{ public : //属性 int m_r; //行为 double calculateZC(){ return 2*pi*m_r; } } int main(){ Circle c1; c1.m_r =10; cout<< c1.calculateZC(); } 访问权限 public 类内，类外都可以访问 protected 类内可以访问，类外不可以访问 儿子可以访问父亲种保护
基础：C++的类与对象——封装
david2000999的博客
05-12 341
C++面向对象的三大特性为：封装、继承、多态 C++认为万事万物都皆为对象，对象上有其属性和行为 例如： ​ 人可以作为对象，属性有姓名、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌… ​ 车也可以作为对象，属性有轮胎、方向盘、车灯…,行为有载人、放音乐、放空调… ​ 具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类 4.1 封装 4.1.1 封装的意义 封装是C++面向对象三大特性之一 封装的意义： 将属性和行为作为一个整体，表现生活中的事物 将属性和行为加以权限控制 封装意义一： ​
1>D:\C++练习\C++代码\C++面向对象\类和对象-封装\Release\类和对象-封装.exe : fatal error LNK1169: 找到一个或多个多重定义的符号
05-18
这个错误通常是由于同一个符号被多次定义引起的，可能是因为在多个源文件中定义了同一个全局变量或函数。要解决该错误，可以尝试以下几个步骤： 1.检查头文件是否被正确地包含，并确保头文件只包含一次。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值