【C++总结】05：封装

已于 2024-03-09 08:18:32 修改
阅读量1.3k 收藏 2
点赞数
分类专栏： C++ 文章标签： c++ template method
于 2022-03-13 00:18:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49167174/article/details/123453080
版权

封装

OVERVIEW

C++面向对象的三大特性为：封装、继承、多态。万物皆为对象，对象有其相应的属性和行为。

一、封装：

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

1.封装的意义：
  1. 将属性和行为作为一个整体，表现生活中的事物。
  2. 将属性和行为加以权限控制。
#include<iostream>
using namespace std;

const double PI = 3.14;

//设计一个圆类，求圆的周长
class Circle {
public:
    int r;
    double calculate() {
        return 2 * PI * r;
    }
};

int main() {
    //通过Circle类创建具体的对象(对象实例化)
    Circle c1;
    //通过对象给对象的属性赋值
    c1.r = 10;
    //通过对象的方法计算圆的周长
    cout  << "圆的周长为" << c1.calculate() << endl;

    return 0;
}

image-20211207223021713

注意：c中的struct结构体（默认为公有）与cpp中的class类（默认为私有）唯一的区别在于默认的访问权限不同。

2.封装访问权限：

访问权限包括三种：

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

注意protected权限与private权限之间的区别：继承的子类是否可以访问到父类protected权限中的内容。

3.成员属性私有化：
  • 优点1：将所有成员属性设置为私有，可以自己控制读写权限。
  • 优点2：对于写权限，可以检测数据的有效性。
#include<iostream>
using namespace std;

class Person {
private:
    string name;
    int age;
public:
    void setName(string n) {
        name = n;
    }
    string getName() {
        return name;
    }
    void setAge(int a) {
        //检测数据的有效性
        if (a < 0 || a > 150) {
            cout << "输入数据无效！" << endl;
            return ;
        }
        age = a;
    }
    int getAge() {
        return age;
    }
};

int main() {
    Person person;
    person.setName("luochenhao");
    person.setAge(-3);
    person.setAge(20);

    cout << "姓名为：" << person.getName() << endl;
    cout << "年龄为：" << person.getAge() << endl;
    system("pause");
    return 0;
}

image-20220111105450529

4.封装案例—点与圆的关系判断：
#include <iostream>
using namespace std;

//1.设计点类
class Point{
public:
    void setX(int m){
        x = m;
    }
    int getX(){
        return x;
    }
    void setY(int n){
        y = n;
    }
    int getY(){
        return y;
    }
private:
    int x;
    int y;
};

//2.设计圆类
class Circle{
public:
    //(1)设置&获取半径
    void setR(int z) {
        r = z;
    }
    int getR() {
        return r;
    }
    //(2)设置&获取圆心
    void setCenter(Point p) {
        c = p;
    }
    Point getCenter(){
        return c;
    }
private:
    int r;
    Point c;
};

//3.设计判断点与圆的关系类
void isInCircle(Circle &c, Point &p){
    //(1)计算两点之间距离的平方
    int distance =
    (c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +
    (c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());
    cout << distance << endl;
    //(2)计算半径的平方
    int rDistance = c.getR() * c.getR();
    cout << rDistance << endl;
    //(3)判断点在圆的位置关系
    if(distance == rDistance) {
        cout << "点在圆上" << endl;
    } else if(distance > rDistance) {
        cout << "点在圆外" << endl;
    } else {
        cout << "点在圆内" << endl;
    }
}

int main() {
    //模拟测试
    //(1)创建圆
    Point center;
    center.setX(10);
    center.setY(0);
    Circle c;
    c.setR(10);
    c.setCenter(center);
    //(2)创建点
    Point p;
    p.setX(10);
    p.setY(10);
    //(3)判断关系
    isInCircle(c, p);

    system("pause");
    return 0;
}

image-20220115222155859

5.封装后类的分文件编写：

创建一个project文件，对封装案例进行分文件编写：

报错处理：redefinition of class xxx，了解关于#ifndef，#define和#endif的实际作用。

文件结构：

image-20220115231921186

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

void isInCircle(Circle &c, Point &p){
    //(1)计算两点之间距离的平方
    int distance =
    (c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +
    (c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());
    cout << distance << endl;
    //(2)计算半径的平方
    int rDistance = c.getR() * c.getR();
    cout << rDistance << endl;
    //(3)判断点在圆的位置关系
    if(distance == rDistance) {
        cout << "点在圆上" << endl;
    } else if(distance > rDistance) {
        cout << "点在圆外" << endl;
    } else {
        cout << "点在圆内" << endl;
    }
}

int main() {
    //模拟测试
    //(1)创建圆
    Point center;
    center.setX(10);
    center.setY(0);
    Circle c;
    c.setR(10);
    c.setCenter(center);
    //(2)创建点
    Point p;
    p.setX(10);
    p.setY(10);
    //(3)判断关系
    isInCircle(c, p);

    system("pause");
    return 0;
}

#ifndef POINT_H_INCLUDED
#define POINT_H_INCLUDED

#include <iostream>
using namespace std;

class Point{
public:
    void setX(int m);
    int getX();
    void setY(int n);
    int getY();
private:
    int x;
    int y;
};

#endif // POINT_H_INCLUDED

#ifndef CIRCLE_H_INCLUDED
#define CIRCLE_H_INCLUDED

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

class Circle{
public:
    void setR(int z);
    int getR();
    void setCenter(Point p);
    Point getCenter();
private:
    int r;
    Point c;
};

#endif // CIRCLE_H_INCLUDED

#include "point.h"

//注意"Point::"用于声明该函数为Point作用域下的一个成员函数
void Point::setX(int m){
    x = m;
}
int Point::getX(){
    return x;
}
void Point::setY(int n){
    y = n;
}
int Point::getY(){
    return y;
}

#include "circle.h"

void Circle::setR(int z) {
    r = z;
}
int Circle::getR() {
    return r;
}
void Circle::setCenter(Point p) {
    c = p;
}
Point Circle::getCenter(){
    return c;
}

image-20220115232124743

二、友元：

在程序中有些私有属性也想让类外特殊的一些函数 or 类进行访问，就需要使用到友元技术。

友元的目的就是让一个函数 or 类访问另一个类中的私有成员，友元的关键字为friend。

友元的三种实现包括：全局函数做友元、类做友元、成员函数做友元

1.全局函数做友元：

全局函数做友元的关键实现：friend void 全局函数名();

#include<iostream>
using namespace std;

//1.建筑物类
class Building{
    friend void goodGay(Building *building);//关键语句:将全局函数设置为友元
public:
    Building(){
        sittingRoom = "客厅";
        bedRoom = "卧室";
    }
    string sittingRoom;
private:
    string bedRoom;
};

//2.全局函数
void goodGay(Building *building){
    cout << "好基友的全局函数正在访问：" << building->sittingRoom << endl;
    cout << "好基友的全局函数正在访问：" << building->bedRoom << endl;
}

void test01(){
    Building building;
    goodGay(&building);
}

int main(){
    test01();

    system("pause");
    return 0;
}

image-20220124000952739

2.类做友元：

类做友元的关键实现：friend class 友元类名;

#include<iostream>
using namespace std;

class Building;
class GoodGay{
public:
    GoodGay();
    void visit();//参观函数访问Building中的属性
private:
    Building *building;
};

class Building{
    friend class GoodGay;//设置GoodGay类可以访问Buiding类中的私有成员
public:
    Building();
    string sittingRoom;
private:
    string beddingRoom;
};

//1.类外实现构造函数Building进行初始化操作，初始化string字符串操作
Building::Building(){
    sittingRoom = "客厅";
    beddingRoom = "卧室";
}

//2.类外实现构造函数GoodGay进行初始化操作，初始化指针指向堆区的一块内存
GoodGay::GoodGay(){
    building = new Building;
}

void GoodGay::visit(){
    cout << "好基友类正在访问：" << building->sittingRoom << endl;
    cout << "好基友类正在访问：" << building->beddingRoom << endl;
}

void test01(){
    GoodGay goodGay;
    goodGay.visit();
}

int main(){
    test01();
    system("pause");
    return 0;
}

image-20220126192505639

3.成员函数做友元：

成员函数做友元的关键实现：friend 类名::成员函数名();

#include<iostream>
using namespace std;

class Building;
class GoodGay{
public:
    GoodGay();
    void visit1();//成员函数visit1可以访问到Building中的私有内容
    void visit2();//成员函数visit2不可以访问到Building中的私有内容
private:
    Building *building;
};

class Building{
    friend void GoodGay::visit1();//设置GoodGay类中的成员函数visit1可以访问Buiding类中的私有成员
public:
    Building();
    string sittingRoom;
private:
    string beddingRoom;
};

//1.类外实现构造函数Building进行初始化操作，初始化string字符串操作
Building::Building(){
    sittingRoom = "客厅";
    beddingRoom = "卧室";
}

//2.类外实现构造函数GoodGay进行初始化操作，初始化指针指向堆区的一块内存
GoodGay::GoodGay(){
    building = new Building;
}

void GoodGay::visit1(){
    cout << "visit1函数正在访问：" << building->sittingRoom << endl;
    cout << "visit1函数正在访问：" << building->beddingRoom << endl;
}

void GoodGay::visit2(){
    cout << "visit2函数正在访问：" << building->sittingRoom << endl;
    //cout << "visit2函数正在访问：" << building->beddingRoom << endl;
}

void test01(){
    GoodGay goodGay;
    goodGay.visit1();
    goodGay.visit2();
}

int main(){
    test01();
    system("pause");
    return 0;
}

image-20220126194609264

注意：在程序中多个类之间存在相互联系，且需要类外实现构造函数需要特别注意书写顺序，否则容易报错。

hello world 999
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++课程设计：年历显示
12-26
【C++课程设计：年历显示】是一个典型的C++编程实践项目，主要目的是让学生掌握C++语言的基础知识，以及在实际应用中如何处理日期和时间的相关问题。在这个项目中，学生需要编写一个程序，能够根据用户输入的年份，...
C++基础入门：面相对象编程C++中的封装、继承和多态.docx
08-06
总结来说，C++的面向对象特性——封装、继承和多态，为程序设计提供了更灵活、更具表达力的方式。封装确保数据安全，继承促进代码重用，多态则允许灵活的接口处理。在实际编程中，熟练掌握这三个概念及其应用，能...
C++ 封装
个人技术博客
11-02 2114
一、封装 1、面向过程与面向对象 面向过程：面向过程是一件事“该怎么做”，是分析解决问题的步骤，然后用函数把这些步骤一步一步的实现，然后在使用的时候一一调用则可。 面向对象：面向对象是一件事“该谁来做”，然后那个“谁”就是对象。是以对象为核心，关注需要哪些对象，对象需要具备哪些功能，然后创建出解决问题的对象，利用对象调用相应的方法即可。采用OOP方法时，首先从用户的角度考虑对象，描述对象所需的数据以及描述用户与数据交互所需的操作。完成对接口的描述后，需要确定如何实现接口及存储数据。 ...
bilibiliC++16-22类和对象-封装
aiqq136的博客
02-04 510
4 类和对象 C++面向对象的三大特性为：封装、继承、多态 C++认为万事万物都皆为对象，对象上有其属性和行为 例如： ​ 人可以作为对象，属性有姓名、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌… ​ 车也可以作为对象，属性有轮胎、方向盘、车灯…,行为有载人、放音乐、放空调… ​ 具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类 4.1 封装 4.1.1 封装的意义 封装是C++面向对象三大特性之一 封装的意义： 将属性和行为作为一个整体，表现生活中的事物 将属性和行为加以权限控制
C++的封装
最新发布
weixin_56799061的博客
04-22 660
C++封装是一种面向对象编程的概念，指的是将数据和操作数据的函数捆绑在一起，形成一个类（class）。这样可以提高代码的安全性和可维护性，同时简化了类的使用方式，使得代码更易于理解和使用。(5). 实现类的接口和实现分离：封装使得类的接口和实现相分离，使得类的用户只需要关注接口，而不需要关心实现细节。(2). 简化接口：通过封装，可以将相关的数据和操作封装在一起，提供简洁清晰的接口，使代码更易于理解和使用。(1). 信息隐藏：封装可以隐藏类的实现细节，只暴露必要的接口，提高了代码的安全性和可维护性。
c++：封装、继承、多态
嵌入式小企鹅的博客
11-04 1712
封装是面向对象编程中的一种重要概念，它将数据和操作封装在一起，形成一个“黑盒子”，对外部只暴露必要的接口，隐藏内部实现细节。C++通过类（Class）来实现封装，其中包括私有成员（Private）、保护成员（Protected）和公有成员（Public）等访问控制修饰符。私有成员只能在类内部访问，保护成员可以在类及其子类中访问，公有成员可以在任何地方访问。首先，在介绍封装前，应该要知道类和对象这么一个事，什么是类和对象？
C++：封装
青瓦松
12-03 648
C++：封装 一、封装的定义 -隐藏对象的属性和实现细节，仅对外公开接口和对象进行交互，将数据和操作数据的方法进行有机结合。 函数是封装的一种形式：函数所执行的细节行为被封装在函数体内，被封装的元素隐藏了其实现细节，可调用函数但不可访问函数内部语句。 二、访问权限符 1、public(共有)：类外可以访问； 2、private(私有)：类外不可访问，继承类亦不可访问； 3、protected(保护)：类外不可访问，继承类可访问。 4、作用范围：在该类作用域内，一个访问权限符出现位置起到..
C++类和对象—封装（属性和行为作为整体，设计学生类，访问权限，class和struct的区别，成员属性私有化，设计案例（1立方体类，2点和圆的关系（多文件编程）））
qq_63055790的博客
01-20 406
C++认为万事万物都皆为对象，对象上有其属性和行为比如说：人可以作为对象，属性有姓名，年龄，身高，体重等等。行为有走，跑，跳，吃饭，唱歌。车也可以作为对象，属性有轮胎，方向盘，车灯。行为有载人，放音乐，开空调等等。具有相同性质的对象，我们可以抽象为类，人属于人类，车属于车类。封装。
C++程序封装函数（函数中有类怎么封装）
weixin_53111112的博客
07-06 582
void b();void c();void d();void e();void f();void g();void h();void i();void j();new.a();new.b();new.c();new.d();new.e();
理解C++编程中的std::function函数封装
09-02
总结来说，`std::function`是C++11中引入的一个重要的功能，它使得函数和方法的封装更加灵活，提升了代码的可维护性和可扩展性。无论是用于封装自由函数、Lambda表达式、函数指针，还是成员函数和函数对象，`std::...
C++库封装JNI接口-实现java调用c++
09-12
总结，C++库封装JNI接口实现Java调用C++涉及的主要步骤包括：声明Java中的本地方法，生成JNI头文件，编写C++实现，编译成库，最后在Java中加载并调用。这个过程需要理解Java和C++之间的数据类型转换，以及如何在两种...
C#封装C++函数工具
11-08
C#封装C++函数工具，可以实现C++代码转换成C#代码，很好用
C++课程设计：大赛打分系统
12-26
面向对象编程（OOP）是C++的核心特性之一，它将数据和操作数据的方法封装在一起，形成类。在大赛打分系统中，可以创建"队伍"类，包含队伍名、队员信息等属性，并提供添加、删除队员等方法；"比赛"类则包括比赛名称、...
C++课程设计：图书管理系统
12-26
同时，还需要设计合理的类结构，实现对象的封装、继承和多态性，以便于管理和操作这些信息。 在C++中，我们可以创建一个`Book`类来表示图书，包括书名、作者、出版社、ISBN号等属性，以及借阅、归还等方法。此外，...
C++程序设计-封装、继承多态应用示例
05-09
总结来说，"C++程序设计-封装、继承多态应用示例"是一个很好的教学资源，它通过一个生动的龙与人战斗场景，帮助初学者理解并实践了面向对象编程的关键概念。通过这个示例，学习者不仅可以了解这些理论知识，还能通过...
c++总结_ThereThere_c++总结_
10-02
在C++初步知识的总结中，我们首先需要理解基本语法和数据类型。C++支持整型（如int）、浮点型（如float和double）、字符型（char）以及布尔型（bool）。变量声明时需要指定类型，并遵循一定的语法规则。例如，`int ...
cpp之STL
阿东的学习记录
02-28 1051
Iterator（迭代器）模式又称游标（Cursor）模式，用于提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。或者这样说可能更容易理解：Iterator模式是运用于聚合对象的一种模式，通过运用该模式，我们可以在不知道对象内部表示的情况下，按照一定顺序（由iterator提供的方法）访问聚合对象中的各个元素。
理解c++类-封装(附案例)
qwedjnd的博客
11-07 1458
文章目录一、类-封装二、案例 一、类-封装 封装原则：隐藏对象的属性和实现细节，仅对外公开接口，并且控制访问级别。 在面向对象编程中，用类来实现上面的要求。用类实现封装，用封装来实现高内聚，低耦合。高聚合是说一个对象的功能都在内部搞定，紧紧地结合在一起低耦合是说对象之间的依赖要松散，不要牵一发动全身。只有这样，当系统规模扩大时，才能比较方便。 二、案例 利用c++中类的封装性来计算立方体的面积和体积。 #include<iostream> #include<string> #in
一个c++封装实例
whatiwhere的博客
02-05 4548
定义一个Student类，包含名字一个数据成员，使用get和set函数封装名字这个数据成员。在main函数中通过new实例化对象，并打印其相关函数。 #include #include using namespace std; /** * 定义类：Student * 数据成员：m_strName * 数据成员的封装函数：setName()、getName() */ clas
C语言封装INI文件类
07-17
以下是一个简单的示例，展示了如何使用C语言封装一个INI文件类： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> // 定义INI文件类结构体 typedef struct { char* filename; } IniFile; // 初始化INI文件类 void IniFile_Init(IniFile* ini, const char* filename) { ini->filename = strdup(filename); } // 释放INI文件类 void IniFile_Free(IniFile* ini) { free(ini->filename); } // 读取INI文件中的值 const char* IniFile_GetValue(IniFile* ini, const char* section, const char* key) { FILE* file = fopen(ini->filename, "r"); char line[256]; // 假设每行不超过256个字符 // 遍历文件中的每一行 while (fgets(line, sizeof(line), file)) { // 查找section if (strstr(line, section)) { // 查找key while (fgets(line, sizeof(line), file)) { if (strstr(line, key)) { // 提取value char* value = strchr(line, '='); if (value) { value++; // 跳过等号 value[strcspn(value, "\r\n")] = '\0'; // 去除换行符 fclose(file); return value; } } } } } fclose(file); return NULL; // 未找到对应的section和key } // 示例用法 int main() { IniFile ini; IniFile_Init(&ini, "config.ini"); const char* value = IniFile_GetValue(&ini, "SectionName", "KeyName"); if (value) { printf("Value: %s\n", value); } else { printf("Value not found.\n"); } IniFile_Free(&ini); return 0; } ``` 在上述示例中，我们定义了一个`IniFile`结构体，该结构体包含一个`filename`字段用于存储INI文件的路径。 首先，我们使用`IniFile_Init`函数初始化`IniFile`结构体，并指定INI文件的路径。 然后，我们使用`IniFile_GetValue`函数来读取INI文件中的值。该函数接受两个参数：`section`和`key`，并返回对应的值。在函数内部，我们使用标准C库函数来逐行读取INI文件，查找指定的section和key，并提取对应的value。 最后，我们在示例的`main`函数中展示了如何使用封装的INI文件类。你可以根据实际需求修改和扩展这个示例。 希望这个示例能够帮助你封装一个简单的INI文件类。如果有任何进一步的问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值