C++之类与封装

最新推荐文章于 2024-07-20 18:10:49 发布
最新推荐文章于 2024-07-20 18:10:49 发布
阅读量147 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49507996/article/details/119974772
版权

文章目录

类（class）

C++与C最大的一个区别就是，比C语言要多很多面向对象的特性，而对象的体现很多都是在类上。C语言中会把很多功能封装在一个函数中，而在C++中多了一个概念也就是类，虽然面向对象的执行效率不高，但是代码会比较整齐。要对面向对象有深入了解可以先从类下手。

如何定义一个类
class p{
	/*代码体*/
}；

类和结构体定义会比较类似，但是它们也是有区别的，首先是他们的访问默认权限，在类中如果不声明权限，那么默认是private私有的，结构体默认访问权限是public公有的，然后在C++中有规定，任何不同的对象不能拥有相同的内存地址，对于空类或空结构体他们的大小都为1。

封装

封装顾名思义就是把类中的成员遮蔽起来，不能让外界直接访问类中的成员，只能通过类中留下的访问接口，来访问或者修改类中的成员，这样的好处就是安全，能够最大限度的保证你的内部数据不会被外界轻易的修改，C++有这三种关键字来修饰访问权限，public、protected、private，外界对类访问的权限逐渐降低，所以尽量把类中的成员变量都用private修饰。

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

class person{
        public:
                void getName(){
                        cout<<"name is"<<m_name<<endl;
                }
                void setName(string name){
                        m_name=name;
                }
        private:
                int m_age;
                string m_name;
};
int main(){
        person p1;
        p1.setName("张三");
        p1.getName();
       非法调用// cout<<p1.m_name<<endl;
        return 0;
}

例一

这里简单的实现一个封装，使实例的对象无法直接访问成员变量，否则会出错

构造函数

我们除了给变量初始化除了通过实例化对象赋值，还可以用其他方法赋值吗，当然是可以的，这里就用到了C++类中的构造函数，构造函数是怎么样一个结构呢，他是一个名字和类名相同，但是不需要加任何返回值类型的函数。

举例有一个类class p{
	构造函数：p(){

		}
}；

既然是函数那肯定可以跟上参数的，当带上参数时，它就是带参构造函数，当程序员不在类中定义构造函数时，会默认生成一个无参的构造函数，构造函数可以根据自己的实际需求来写。

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

class person{
        public:
                person(){
              		  cout<<"这是无参构造方法"<<endl;
                }
                person(string name){
                	cout<<"这是带参构造方法"<<endl;
                        m_name=name;
                }
                void getName(){
                        cout<<m_name<<endl;
                }
        private:
                int m_age;
                string m_name;
};
int main(){
        person p1("张三");
        p1.getName();
        person p2;
        return 0;
}

请添加图片描述
这里可以看到，带参构造函数和无参构造函数是可以同时存在于类中的，调用取决于在实例化对象时是否传递了参数，这里需要注意当调用无参构造函数时，不需要加()，否则会被编译器当成普通函数的声明，除了直接在括号内像普通函数一样传参，还可以用一种方法传参，它就是初始化列表，顾名思义就是用来做初始化用的。如下

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

class person{
        public:
                person(string name,int age):m_name(name),m_age(age){
                cout<<"这是带参构造方法"<<endl;
                }
                void getName(){
                        cout<<m_name<<"的岁数是："<<m_age<<endl;
                }
        private:
                int m_age;
                string m_name;
};
int main(){
        person p1("张三",36);
        p1.getName();
        person p2;
        return 0;
}

请添加图片描述

析构函数

除了默认有构造函数外还会有一个析构函数，析构函数是在某个实例化对象结束运行之后，用来释放空间用的,并且不可以有参数，不可以发生重载。

格式是类person{ 
		析构函数：~person(){

	}

}

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

class person{
        public:
                person(){

                cout<<"这是无参构造方法"<<endl;
                }
                person(string name,int age):m_name(name),m_age(age){
                cout<<"这是带参构造方法"<<endl;

                }

                ~person(){
                cout<<"这是析构函数"<<endl;
                }
                void getName(){
                        cout<<m_name<<"的岁数是："<<m_age<<endl;
                }
        private:
                int m_age;
                string m_name;
};


int main(){
        person p1("张三",36);
        p1.getName();
        person p2(p1);
        p2.getName();
        return 0;
}

请添加图片描述
可以看到析构函数都是最后才运行，所以作用就是用来释放对象的内存空间的

拷贝构造函数

除了默认有一个无参构造函数外，第三个会有一个默认的拷贝构造函数，它的作用是当实例化好一个一个对象后，把这个对象当作参数传递给拷贝构造函数，被拷贝的对象会把所有对象成员赋值一遍给目的对象。

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

class person{
        public:
                person(){

                cout<<"这是无参构造方法"<<endl;
                }
                person(string name,int age):m_name(name),m_age(age){
                cout<<"这是带参构造方法"<<endl;

                }
                /*person(const person &p){
                        cout<<"这是拷贝构造函数"<<endl;
                        m_name=p.m_name;
                        m_age=20;
                }*/
                void getName(){
                        cout<<m_name<<"的岁数是："<<m_age<<endl;
                }
        private:
                int m_age;
                string m_name;
};
int main(){
        person p1("张三",36);
        p1.getName();
        person p2(p1);
        p2.getName();
        return 0;
}

默认拷贝构造函数会全部拷贝，所以也可以自己写拷贝构造函数，如上

注释掉后

请添加图片描述

未注释

请添加图片描述
注意这里拷贝构造函数的参数是引用，而且必须加上const修饰

浅拷贝与深拷贝

浅拷贝是指拷贝函数直接在数值上直接拷贝，没有用到指针类型的参数，可以用到浅拷贝，若是用到了指针类型的，就可以用深拷贝，来重新申请一段空间，因为用到了指针类型的参数必定会遇到空间创建与释放的操作，那么如果只用了浅拷贝就会导致内存重复释放的危险。

浅拷贝(重复释放导致段错误)

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

class person{
        public:
                person(){

                cout<<"这是无参构造方法"<<endl;
                }
                person(string name,int age){
                cout<<"这是带参构造方法"<<endl;
                        m_age=new int(age);

                }
				  ~person(){
                        if(m_age!=NULL){
                                delete m_age;
                                m_age=NULL;
	                       }
                cout<<"这是析构函数"<<endl;
                }
                person(const person &p){
                        cout<<"这是拷贝构造函数"<<endl;
                        m_name=p.m_name;
                		m_age=p.m_age;默认拷贝构造函数的做法
                //        m_age=new int (*p.m_age);
                }
                void getName(){
                        cout<<m_name<<"的岁数是："<<*m_age<<endl;
                }
        private:
                int *m_age;
                string m_name;
};
int main(){
        person p1("张三",36);
        p1.getName();
        person p2(p1);
        p2.getName();
        return 0;

请添加图片描述

深拷贝

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

class person{
        public:
                person(){

                cout<<"这是无参构造方法"<<endl;
                }
                person(string name,int age){
                cout<<"这是带参构造方法"<<endl;
                        m_age=new int(age);

                }
				  ~person(){
                        if(m_age!=NULL){
                                delete m_age;
                                m_age=NULL;
	                       }
                cout<<"这是析构函数"<<endl;
                }
                person(const person &p){
                        cout<<"这是拷贝构造函数"<<endl;
                        m_name=p.m_name;
                //		m_age=p.m_age;默认拷贝构造函数的做法
                        m_age=new int (*p.m_age);
                }
                void getName(){
                        cout<<m_name<<"的岁数是："<<*m_age<<endl;
                }
        private:
                int *m_age;
                string m_name;
};
int main(){
        person p1("张三",36);
        p1.getName();
        person p2(p1);
        p2.getName();
        return 0;

请添加图片描述
这里可以思考一个问题，当一个类里有另一个类作为成员时，那么各自的构造函数和析构函数是谁先运行，谁后运行呢？我们可以实践一下。

#include <iostream>
using namespace std;
 class student{
        public:
                student(){
                        cout<<"这是类1的构造函数"<<endl;
                }
                ~student(){
                        cout<<"这是类1的析构函数"<<endl;
                }
};
class person{
        public:
                person(){
                        cout<<"这是类2的构造函数"<<endl;
                }
                ~person(){
                        cout<<"这是类2的析构函数"<<endl;
                }
        student s1;
};
int main(){
        person p1;
        return 0;
}

请添加图片描述
这里可以看到先运行被调用的类的构造函数，然后是本类的构造函数，然后是本类的析构函数，然后才是被调用的类的析构函数。

@默默学习
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
函数，封装，参数
weixin_44321299的博客
01-17 687
1.函数： 函数就是一种封装 2.定义函数： function 函数名(){ 函数体; } 3.函数不会自动执行，需要被调用才可以执行 函数名(); 4.函数命名规则： 与变量命名规则一致 1）以字母、、开头2)可以包含数字、字母、、_开头 2)可以包含数字、字母、、开​头2)可以包含数字、字母、、_ 3）区分大小写 4）不能使用关键字和保留字 驼峰命名法：若名称由多个单词组成，则从第二...
杂记，类、函数的封装作用
natural_Caduceus
11-16 263
最近对我的“嗅图狗”添加新功能，发现过去那种“面向过程”式的设计比较难改，尤其是为了打包exe将所有文件都放到同一个代码文件后……函数之间传值就弄个全局变量，神似硬件里的“搭飞线”。改起来也是麻烦的可以…… 函数是“对程序段，功能”的打包，比较像是“集中起来弄成芯片” 类是“向对象，职能”的打包，比函数多了一种“层”的感觉，像是“模块打包，露出接口线的插头” ……以后有时间把我重构的过程放上来。 ...
C++小白学习笔记（二）函数、封装、与类
qq_51214753的博客
07-09 246
C++小白学习笔记（二）函数、封装、与类 因为是总结的学习笔记，所以内容可能有点杂，欢迎大佬补充指正。 函数可以有默认参数 如果我们传入数据，那么就用我们传的数据，如果没有就用默认值 语法：返回值类型 函数名（形参 = 默认值）{} void swap(a,b=10) { int temp = a; a = b; b = temp; } swap(10, 20); //可以传数据 swap(5);//也可以不传 注意： 1.如果某个位置已经有了默认参数，那么从这个位置后 都要有默认值
js,php,java的类封装和函数封装,什么时候使用类封装,什么时候使用函数封装
weixin_42137023的博客
07-05 535
类封装是面向对象的，函数封装是面向过程的，在重点不同 函数封装是对单一的方法（功能）进行封装，类封装是对单一类功能的封装
c#语言—类与函数
冯浩月
03-31 794
前言 之前我们谈到了面向对象的基础知识，接下来，小编带大家更深入地了解一下类及其方法的内容，其中会涉及到一些具体的小知识。 类与函数  一、类的成员  包含了字段，属性和方法。如图所示 二、构造方法 1.作用： 用来创建对象，并且可以在构造函数中对对象进行初始化。 2.构造函数 （1）构造函数是用来创建对象的特殊方法，方法名和类名一
C++ 之类的封装
2301_76185999的博客
03-12 362
C++ 之类的封装
C++类的封装
BIUZJ的博客
09-12 981
即开发过程中，以解释型的逐条语句执行方式来进行调试，以编译型的脱离开发环境而启动运行的方式来生成程序最终的执行代码。1.C++是一种面向对象的计算机程序设计语言，作为C语言的继承，C++不仅能进行C语言的过程化程序设计，而且可进行以抽象数据类型为特点的基于对象的程序设计，还能进行基于过程的程序设计；如果程序的编写是正确的，那么通常只需按一个功能键，即可搞定这个过程。该过程实际上分成两个步骤。封装：把一类事物的属性和行为用类这种自定义的数据类型包起来，把需要隐藏的隐藏起来，把可以暴露的暴露出来，这就叫封装。
深入解析C++编程中类的封装特性
09-03
在C++编程中，类的封装特性是面向...总的来说，C++的类封装特性是构建面向对象软件的基础，它促进了代码的组织、复用和保护，提高了软件的稳定性和可维护性。理解和熟练运用封装是成为一名合格的C++程序员的关键步骤。
C++ MD5加密封装类
01-12
MD5是用于对信息生成信息摘要（即散列码）的算法之一。不管文件多大，经过MD5后都能生成唯一的MD5值。好比现在的ISO校验，都是MD5校验。怎么用？当然是把ISO经过MD5后产生MD5的值。一般下载linux-ISO的朋友都见过...
C++类的封装之 字符串MyString类
01-06
包括了运算符重载<> = + == [ ] mystring.h #ifndef MYSTRING_H #define MYSTRING_H #include using namespace std; class MyString { friend ostream& operator<>(istream& in,MyString& ob);...
C++类封装实习
11-14
在C++编程中，类封装是面向对象编程（OOP）的核心概念之一。它涉及到将数据和操作这些数据的方法捆绑在一起，形成一个独立的单元，称为类。类封装的主要目标是实现数据的安全性和代码的模块化，使得程序更加易于理解...
C++类封装设计继承
12-15
类封装设计是面向对象编程的基本原则，它允许我们将数据和操作数据的方法捆绑在一起，形成一个独立的单元，以提高代码的安全性和可维护性。 类的封装通过访问修饰符来实现，如public、private和protected。public...
C++中的类与封装
05-22 218
1，类的组合： 1，类不是孤立存在的，类之间都会有一些关系，组合就是类的基本关系之一； 2，电脑一般而言是由 CPU、内存、主板、键盘和硬盘等部件组合而成； 3，学习电脑组装需要多少时间？学习电脑组装是否需要学习显示器、键盘、鼠标、主板、内存等部件的设计与制造？ 1，我们可以使用一个类，但是可能对类的内部状态一无所知； 2，类的...
C++类与封装的概念
热门推荐
年少轻狂，幸福时光
07-16 1万+
--事物的难度远远低于对事物的恐惧！     这节我们来学习类与封装的概念，我们知道，一般电脑都是由CPU、内存、主板、硬盘等部件组合组成，像下边这样     但是我们组装电脑的时候，仅仅是把硬盘、内存、CPU、主板等这些部件的接口相互连接起来就行，我们不会去关注硬盘、CPU、主板等他们的内部是怎么实现的，组装电脑并不需要去了解学习硬盘的设计、主板的设计，直接用他们的接口就行，这就是封装一...
对C++中类和封装的理解
wangshiyi666的博客
02-21 4639
    封装是将相对独立，能够广泛使用的程序功能提炼出来，编写成函数或类等形式的可重用代码。可重用的代码的特点是“一次开发，长期使用”。C++的封装的语法格式用一个简单的例子来看下class Rectangle //长方形类：声明成员{public: double a,b;  //长度：数据成员 double RArea(); //求面积：函数成员 double RLen(); //求周...
模块的封装（一）：C语言类的封装
自由的天空
03-10 8020
出处：http://www.amobbs.com/forum.php?mod=viewthread&tid=5505499 本帖最后由 Gorgon_Meducer 于 2013-6-25 19:11 编辑 [微知识]模块的封装（一）：C语言类的封装     是的，你没有看错，我们要讨论的就是C语言而不是C++语言中类的封装。在展开知识点之
C++类与封装
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-20 310
封装的基本概念 在讲类与封装的概念之前，我们先说一个例子。大家平时应该组装过电脑，我们知道一台电脑通常由四大部分(CPU、主板、内存、硬盘)组成。因此我们在组装电脑的时候，通常仅仅是把CPU、主板、内存、硬盘这些部件的接口相互连接起来就行。我们不必知道这些部件是怎么设计和制造的，仅仅了解如何使用它们各自的接口就行。实际上这就是我们生活中一个封装的例子。 由此我们可以得到封装的基本概念或者基本特征。...
C语言 之 理解指针（1）
最新发布
fallzzzzz的博客
07-20 1184
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++中类与对象的封装与访问方法
类是用户自定义的数据类型，用于封装数据和与之相关的行为。在C++中，类包含数据成员（即属性，如姓名、年龄等）和成员函数（行为抽象，如设置时间和显示时间等操作）。通过对象或对象指针来访问类的这些成员。 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值