栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

C++学习笔记(三)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

C++学习笔记(三)

文章目录
  • RTTI运行时确定对象类型初步理解
  • 三种cast的深入理解:并非一刀切
  • 自动推导
    • auto关键字
    • declare_type
    • auto与declare_type
  • struct和class的理解
  • 静态分配与动态分配
  • this关键字
  • C++新增语言特性的目的
    • const变量和宏定义相似,但是区别在哪
    • inline函数本质提高的是运行时的效率
  • 模板的初步理解
    • C++语言的高级之处:抽象
  • 异常处理机制
    • try catch机制
      • 为什么要用try_catch机制
      • 为什么要有异常的throw列表
  • 自由存储区
  • 内存泄漏和内存碎片
  • new和malloc的区别
    • new不能强转
    • C++基本都用new,没必要用malloc
  • 智能指针
    • 多封装了一些东西,使其变得更智能
    • 智能指针比普通指针消耗资源多
  • java垃圾回收机制
    • java的效率不取决于程序员而是JVM虚拟机
    • 垃圾回收用的是GC线程
    • 垃圾回收的两种方法
      • 引用计数法
      • 可达性分析法

RTTI运行时确定对象类型初步理解

这个C加加里面有一个运行时确定对象类型,就是原因就是在于它其实面向对象的时候,他没有向面向过程的样子,你很轻松的就可以判断出对象类型,你再面向过程的时候,你可能你自己内心是很清楚,他是什么类型的,但是当你在面向对象的时候,他会有一些什么继承啊,蜂多肽啊,那些东西,那些东西之后,他就跟外国人起名字一样,就是比如说他的你,你就可像百年孤独里面。那个什么荷赛阿卡,迪奥什么,就他阿卡迪奥,阿卡迪奥,它一直都是这个名字的,所以就是它会有很多那种负类啊,子类啊,它名字基本都是那种一样的,总的来说就是你很难判断它的一个类型,就是说在面向对象的时候,你很难判断它的类型,然后它这个地方就有一个运行时,对象运行时确定对象类型的这样一个东西。

三种cast的深入理解:并非一刀切

七里面的话,他其实基本上是一刀切,就是说他要么是编译器帮你处理了,就是隐式类型转换,它编辑器,你交给编译器他也是处理给你,要么就是显,那就就是完全就是强制类型转换,一刀切就完全给你程序员去做决定了,我编译器不管,然后C加加里面的四种cars,其实是对于这一种方式的一种升级,他把那种你强制类型转换嗯,变得更细化了,一下细分了一下不同领域。比如说你如果他你本来这个是对的,编译器可以帮你稍微做一些检查的那种的话,那就是用的是那个,第一种,那个什么就是用的是第一种的那个cast,然后如果你用的是你,你不想让编译器帮你做强制类型做类型检查,然后只是你明确你这边可以知道的,那你就用第二种cast,然后你如果用。

然后你如果是用了一个是关于cos的cos的,你就用了那种细分领域吧。总的来说,就是它是一种对C的一个一刀切,完全一个强制类型转换,交给你程序员自己去管兵器,不管的一种优化,一种升级,让你可以让编译器尽可能的帮你去做一些东西,去帮你去查一些错误,你比如说他之前那个第二种cast,你那样写的话,那就证明你是知道的。你是明确的是知道你是这里是要进行强制类型转换的,而不是你不小心写错的,是吧,如果你是像西那一刀切,那很有可能是你自己写错了,这样的话就有点难搞,所以他就是有一个比较升级的,帮你更加的一个,帮助你更加的一个去查找错误。

自动推导

C加加里面的自动推导,就是说你在定义一个变量的时候,你没有明确告诉他的类型,然后编译器是通过他的一些周边,通过他的一些判断去推导,比如说他周边的一些东西,去判断推导得到数据类型,这就是C加加里面的自动类型推导。

auto关键字

Auto关键字,其实在C语言里面就有了,就是我们其实在C语言里面定义一个局部变量的时候,其实它本来它的局部变量的前面就应该加一个auto的,只不过我们省略了,就比如说我们定义了一个局部变量,比如说a,其实实际上就是auto into a,只不过我们是省略掉了auto而已。

在C加加里面auto,他做了一个废物利用来着,所以说C加加里面auto,它是一个全新的一个关键字。

Tu在C加加里面,你必须版本要不能低于C加加11才能够用。

他那个有一个auto自动推导吗?它有一个oppo跟一个declare type这两种方式,然后呢,他这两种方式都是可以进行自动推导的。那个oppo的话,它有一个问题就是你会觉得他为什么要用这样一个自动推导,其实就是他在那个后面,她用了她用的地方是在后面的,比如说他的一个模板饭行啊。这些东西在那个情况下,你其实你自己是很难知道你要定义的这个东西的类型的,就你当时是肯定是不能确定的,只能是用这个o头去进行一个自动推导,然后这个o头的话,它有一个注意事项,就是你o头后面的那个变量,它不能够是你,比如说你o头后面。

比如说你o tu后面,它有一个有一个in te,然后你就是不是就是,比如说你OO后面它有一个那个两个值,就是你你同一行里面定义了两个变量,然后这两个变量的话,你是不能够让他其中一个是硬和另外一个差的,就是你o tu里面那一行的,后面的两个变量也必须要保持相同才行,所以他也不也不是说你o tu肉,你前面跟后面可以不一样,比如说你o抽一个a等于一个五,然后B等于一个3.3,那这样是不行的,因为你a是等于应适应类型的,B是3.3是大事float类型的,这样就不行。

declare_type
int i = 5;
decltype(i) j;
auto与declare_type

然后这个declare type呢,这个declare type也是那个一自动类型推导的,然后这个declare type跟这auto有有区别就有总共有就是有有一些区别,第一个区别就是这个auto的话呢。

啊,有一个区别,就是你用auto的话呢,它是不区分cos的,就是说你如果这个变量,你之前你并定义的那个变量是一个就是是一个那个cost类型的话,他那个o是不会说识别出你是cost类型的,它只是识别那个那个inter,就比如你定义那个cost inter,然后它不会识别到之前的前面的cost,他只会识别到那inch,然后然后如果是declare type的话,它就可以识别到前面的那个cost。

比如说你定义一个cost inch I等于五,然后auto j等于I,这个时候呢,那个J它的一个变量,它auto只会帮你变成一个int类型,不会帮你变成cost int类型。

然后第二个区别就是因为你的这个oppo,他是需要你的幼稚去推断你的这个数据类型的,所以你这个oppo定义的时候,必须得要定义同时进行初始化,只有这样子的话,他才能够嗯,得到它的数据类型吗?就是说你oppo你定义的同时就要进行初始化了,但是这个的CAD的话呢,这的客太谱,你可以不用初始化,你定义就行了,为什么?因为他的课APP它的类型推导,它是通过你那个DK2TOP后面那括号里面的那个表达式推导得到的,不是根据你的幼稚推导得到的,所以你可以在定义的同时不用初始化都可以。

那个cost那里,你如果用的是oppo的话,你他是不会报错了,但是你如果cos的那里,你用的那个是declare type的话,你把它改了,它就会报错,但是你用auto的话,你把它改了,他竟然没有报错,这就说明他oppo里面,它是不识别你前面的cos的,那是declare type它是识别你前面的cos的,所以才会报错,因为要改他,所以他cos就不能给你改,报错OO的话,你改它,它不识别前面cos的,他认为他不,他不知道他是cos的,所以它就可以改,就没有报错。

这个auto跟declare tap,它在后面涉及到一些引用,还有一些指针的节引用,注意前面的引用是引用,后面只是指,后面的说的是指针的节引用,在这两个地方用的时候是会有点不太一样的,这个你知道一个有一个印象就行了,后面遇到再说。

还有一个区别就是这个auto,它其实本质上你要去运行啊,那I它才能够推导出来,但是那个declare type的话,它只需要解析一下就可以知道了,就可以推导出来了。

struct和class的理解

这个structure和这个class其实是这样理解的,就是其实这个structure本身也就是为了打包,然后,其实这个class其实就是这个struck的一个升级版,就是它都是用来打包的,但是你会发现到后面打包的东西越来越多的时候,你就最后就会升级到一个class,就说其实struck,根根class,其实它的功能都是一样的,就是用来打包的,只不过后面庞大了之后就用了class。就定义了class出来,然后你硬要说它有区别,就是class,它是可以定义函数,可以定义一个函数的,里面可以有方法,但是其实这个是不不是太太怎么说的,过去的,因为是drug,它本身结构体里面它也可以定义函数,也可以定义方法,它是用函数指针的方式,间接定义函数,也可以有方法在里面的。

所以其实struck跟class这两个东西其实是功能是是基本上是相同的,Class虽然是struck的一个升级版,但是其实class能做的事情,Structured也能做,Struck能做的事情class也能做,那为什么他会有这两个东西出来呢?其实这个就是,就是有一个比如class,他比strike更升级了一点,就是他这两个东西最后发展之后,出来之后,他强调的东西是不同的,就是你如果强调。C里面的一些面向过程的时候,那么你一般就会用struck的,然后当你强调用面向对象的时候,那么你一般都是用class就。但从本质上来讲,这两个东西没什么太大区别,就是它各自强调的东西不一样,你强调面向对象,那你就用class。

然后这两个有一个区别,就是它struck它是没有权限的,就是你在C里面,哪怕是在家里面,你用struck的话,他是没有访问权限的,就你谁都可以访问,里面东西什么里面的什么东西都可以访问,但是class它有一个权限,就是就就有一些东西,它是不能访问的了。然后他根据权限的层级可以分成private,然后protected跟PUBLIC3种权限在class里面,然后这个这个其实就像你一个一个楼房里面。的一个电,电房一样,这class它里面可有一些变量啊,他可能是不希望你去知道的,也是不希望你去篡改的,因为这是一个嗯,就是说他没有,就说他为了隐藏掉,他觉得这东西你没有必要知道,或者说你知道之后可能会篡改,不安全,就种种细节,他就设置了个权限。

比如说这个楼房,楼房里面有个店店房,靛房一般只有电工才有权限去用,其他人是没有必要知道,也没有权限,就没有必要去做,去知道你知道的可能会需要去篡改,篡改的可能就会导致整个楼房的电用电出现问题,所以他在class类里面,它就会有一个这样这样一个权限的东西,但是在structure里面,就是没有struck里面,你你任何东西都可以访问,它里面的什么东西都可以访问,但是class类的话,它里面有一些东西,它有一个权限,设置了一个权限,权限权限,访问权限,那个东西有一些人他是隐藏掉的细节,然后你他不希望你去篡改他的野,他设了一个访问权限的。

静态分配与动态分配

首先知道一下什么是静态分配跟动态分配,就是全局变量跟局部变量里面的这些,比如说他存在数据段,BSS段,还有那个站里面的这些数据,他就是静态分配的,然后再堆里面的,这这个就是叫做动态分配,就是你需要malloc跟free是动态分配,然后C加加里面有个对象的概念,其实对象就是变量的一个升级吧,就是他的。东西比变量更丰富一点,然后就是对象,就是你可以理解为就是一个丰富版的变量,它也是需要一个有一个内存在在里面用的,就是它也是需要占内存的,然后它的一个它是这个变量,它这个对对象呢,它是跟你在申请堆一样,它都是需要申请的释放的。

而全局变量和局部变量呢,他这种在静态分配里面的,它是自动申请自动释放的,但是你这个对象对象是一个,就是它需要一个申请跟手动申请跟手动释放,就跟那个堆申请堆内存一样,然后他这个对象的一个申请的一个东西的话,就是一个。然后他这个对象申请的话,就是就是有一个申请内存跟释放内存呢,就是用的是一个六根迪利特堆的话,用的是malloc跟free,这两个就是有点不一样,但是其实都是差不多的,只是对象里面他用的是六根迪利特。

那么这个对象跟变量的差别究竟在哪里呢?对象,他在变量变量的基础上多了一个构造函数跟C,够函数就是这样子,就是因为它多了,这个构造函数跟C够函数,所以他才需要手动申请内存跟释放内存,所以才要手才要,才有了一个六根迪利特出来,然后这个嗯,就是说他这个东西它只是提供一个机制而已。就是C加加里面他为什么会用的比较多,这些动态动态分配,就是为什么会用这对象这么多,其实这个是不是他的语言决定的,是他的业务决定的,C加加他的业务就决定了他更多情况下,要用了这种情况。

就是si,他处理的可能是一些比较小的一些业务,所以这个时候呢,你就就是这这个业务就决定了,你可能是走,可能用了那个静态分配多一.si加加,他走一般做的是一些比较大的业务,这些大的业务的话呢,可能比较比较稍微复杂一点,所以他就会涉及到一些,所以他用到了动态分配可能就会多一点,所以用到那个对象的一个六根delete可能就会多一点,这是他C加加的一个业务决定的,这是C跟C加加的业务决定的。

就是说C加加他这个业务决定了他可能要用到的对象的一个六跟迪delete会比较多是这样子来。

这个静态全局变量,它的这个在C加加里面就不建议用了,因为已经可以用命名空间的机制去替代了,但是这个静态局部变量的话,在C加加里面还是大量的使用的,继续沿用的,其实这个静态局部变量本质上就是改变了他的弟子玉跟生命周期嘛,就他本来在站里面,你改变了他弟子欲改变到这个代码段里面去了,不是代码段就是把它放到,把它改变到数据段,BSS段里面去吗。就改变他弟子域,还有生命周期也改变了,就他不是那个时候,站站的那里面就没了,而是他一直带着,然后就是说静态局全局变量,他已经可以用秘名功勋代替代替了,但是静态局部变量的话,在企业家里面还是经常用的,还是大量使用的。

这个static关键字在C加加中又多了一个用法,就是在class类中用,就是你如果用了一个class类里面,如果你是静态的话,那么它静态的它的是属于class的,如果它不是静态的,它就属于对象的,这个你现在目前是听不懂的,所以先记住静态的是属于class,非静态的是属于对象后面,等到学到面向对象之后再去思考,再去想。

这个class类里面放函数其实就是把函数声明放进去,就它跟class,它跟struck不一样,Strike的话你就不能放函数声明,你只能是把函数指针放进去啊,放函数指针class,它升级就升级在它比struck升级,在它直接可以把函数声明放到那个class里面去。

然后他甚至可以把函数体放进去,这就跟之前讲过的inline有一点关系的,可以翻回去之前看online那部分。

不过一般都是直接把函数声明放进去就可以了。

这个类呢,里面定义的函数,你在外面去不是这个类,它声明里面声明的函数,它在外面定义的时候呢,需要用一个两个冒号去指明是这个类里面的函数,因为你想想看,如果不是这样的话呢,是不是所有的类里面的函数都不能重名呢?是不是,所以他肯定就是有一个,你要定义函数的,肯定是先写这个类的名字,在冒号,冒号再写这个函数,所以你就可以理解为,其实这个类的命名空间是有点像的,这类里面的那个东西就是一个命名空间。

然后你去用这个类里面的东西的时候,就跟结构体,跟用结构体是一模一样的,就是什么什么点什么什么,你用里面函数也是你用类的名字,再点函数名就行了。

这个静态的类就是类里面的静态成员,还有静态方法,它是这么用的,就是首先你在那个类里面用一个static去定义那个类里面的变量和函数,当然你这个类里面的函数只是声明而已,然后你再变那个类里面的函数用了static之后。你是不是还要在累的外面去对这个函数进行定义?按道理说,在外面定义也应该加static,是不是?但是这里不用加,为什么?因为为了避免引起歧义,因为你在外面一旦加了static,那么他可能就是跟静态全局变量分不清了。所以C加加设计的时候就是在这里,在外面定义的时候没有用static。

而是指在类里面声明,这个函数的时候用了static,那么这个加了static跟不加static,这个静态成员跟静态方法,跟普通的成员,跟普通方法有什么区别呢?区别就是静态的是属于类地尔,而普通是属于对象的意思就是说,如果你的这个东西是静态的,那么你可以直接用这个类,然后去使用它。而如果你没有用静态,只是用了普通的,那么你首先要定义出一个对象,根据这个类定义出一个对象,再用那个对象加个点,然后去访问他。而如果你用的是静态的,你直接就可以用那个类的名字加一个冒号,冒号,然后再把这个成员变量成员方法,然后给他。

给他写上去,那么就可以直接访问,而不用创建一个对象。

这个类里面的静态成员跟静态方法,实际上用的很少,他在那个单例模式里面会用到,为什么用的很少,因为它这个已经破坏了这个面向对象的思想,在C加加里面一切面向对象,那么一切都是面向对象的的话呢,那你类里面不可能这样子定义,这等于就是说是破坏了这个思想,所以这种情况是一个特例,很少用,但是他在单例模式里面是用到的。

int *p = new int;
*p = 5;
delete p;
int *p = new int(3);
this关键字
void A::func1(void)
{
    //cout << "A::func1, i = " << i << endl;
    cout << "A::func1, i = " << this->i << endl;
}

Si家家里面有一个this关键字,这个是C加加里面新增的一个关键字,这个关键字本质上就是一个指针变量,它这个指针变量是指向那个对象的,就是说他其实是在,它其实是编译器,它自己帮你自动生成的一个指向了他的类里面的那个对象的那个地址的一个指针变量。这个是编译器帮你自动加上去,加在你的定义的那个类里面的,就是说,它是一个帮你自动加进去的一个指针,变量指在你的类里面指向你将它在你们你那个变那个类里面的意义,就是它预先帮你指向了你后面要定义,但是现在还没有定义的那个对象。

就是说他这个历史就是Xie加加在编译器在编译的时候,帮你在你的类里面自动加上去的,这个这个东西,然后他指向你将来可能要用到的,基于这个类的对象,但是现在还不知道是哪个的哪个对象的一个东西,就把它用this来代替,然后这个日子就是指向了那个在未来就是要指向那个对象的,然后为什么会出现这样子,就是因为你。在写这个类的时候呢,可能并不知道你未来的对象是什么,但是你要提前用到这个对象的去进行一个代码的书写,所以你要用一个历史去找去代表他这个对象,等到将来你未来的真的定义对象之后,他的对象的地址就是这个历史的地址了。

然后这个东西就是其实没有那么简单,就是,比如说你如果在你的类里面定义了一个成员方法,也就是一个函数,你这个函数在外面再累的,外面写了之后,比如说你这个函数在外面定义的时候,你用了他这个类里面的一个成员变量,那么你刚刚呢,我们在演示的时候呢,只是比如说你定义那个成员变量叫爱,那么你在这个成员方法里面定义的时候,直接用了唉。其实并没有那么简单,这个是一种省略的写法,其实真正的写法就是用了一个does,然后一个箭头I,这样的话就是代表的是你这个方法,你这个成员方法,你就是这也就是这个函数里面,它的这个I其实就是用的就是你未来的那个对象里面的那个I。

所以他就应该是用了一个历史,然后再指向他那个爱就历史代表未来的那个对象的地址,地址里面的那个爱,而我们为什么只是用了一个爱呢?是因为我们省略了,所以严格来讲应该是does,然后一个箭头,唉,因为你未来要用到这个成员方法,这个函数的时候呢,它其实是基于对象去用的,你是指向的是对象里面的那个爱,所以他应该是历史爱历史箭头,唉。

这个历史理解到这个程度就可以了,具体的深度讲解到后面再看。

这个继承呢?包在里面的是父类,然后外面的才是子类。

子类是继承了父类的所有的东西,然后除此之外还多了一些其他的东西。

C++新增语言特性的目的

C加加里面新增了很多语言的特性,很多都是从一个点出发,就是让编译器能够更好的去理解你的意图,就是很多新增的关键字都是从这点出发,他想让你更好的想让编译器跟你更好的进行一个理解,理解你要干什么。

是他新增的这些关键字,就是尽可能的希望让编译器能够知道你这个程序员写这东西的本意,然后,如果他发现他跟你的本意是相同的,就通过本一跟你的本意有所违背,那就报错,就是尽可能的让编译器知道你的想法,知道你这个程序员的本意。

就是一个出发点,就是希望编译器尽可能的知道我的本意,然后,一旦我们的本意跟我们不小心出现了一个错误,然后他就会发现得到他,我们写东西跟我们想实现东西不一样,那就尽可能的去报错,反正一切语言的是新增的原特性,都是希望能够尽可能的完成这一点。

const变量和宏定义相似,但是区别在哪

之前说过的那个cost变量跟那个宏定义很类似,但是其实它有一点区别,就是cost的变量,它是占内存的,但是宏定义它是不占内存的宏定义,就是预处理之后直接替换掉了,不占内存的,但是cost它是占内存的。

Cost在C语言中有三个用途,一个是cost变量,然后一个是cost数组啊,一个是cost指针,Cost变量。其实跟cos的数组是比较简单的,Cos的数组就是你一次定义多个cos的变量嘛,所以难的地方就是那cost的指针那里。

inline函数本质提高的是运行时的效率

这个inline函数,它本质上提高的效率是在运行时的效率,而不是编译时的效率。其实提升效率本质上就是提升。运行时,因为你编译只有一次嘛,那运行是多次运行,所以一般提升效率都是提升运行时效率。你把online放到那个里面去的话,那它就是运行时效率就高了。

模板的初步理解
template 
T add(T a, T b)
{
    return (a + b);
}
C++语言的高级之处:抽象

CC加加这种语言教C语言,高级就高级在了抽象上,就是说C加加你去学它,有10%是在学他的基础概念,40%是在学它的面向对象,50%是在学他的抽象,那么模板就是其中一个很典型的抽象模板,它是从何而来的,他就是从函数重在发展出来的,就是你一个函数虫在。你同一个函数名,你可以有多种存在方式,那么你是不是你要配合这个函数名,使它能够支持多种类型的话,你如果没有模板,没有抽象,你是不是一次性要定义出十种,20几种十多20种不同数据类型的同一个函数名的一个函数,这样子才可以存在?

但是这样是特别麻烦的,因为你要每一次定义一个函数,你就要定义十几20种类型,让他去虫在,所以因此就出现了一个模板,模板的意思就是说,他把这个函数给抽象出来了,他只用写一次,比如说用个template的T,这个T就代表了它可以试的数据类型。那么后面他会根据一些你实际的一些操作,推断出你实际的数据类型是什么,就是说她在写的时候,就把它抽象成了一个T,这个就是模板的有模板。

然后模板是就是一种C加加的抽象,S te l库就是就是一帮大神写的这个模板,给你们这些人去使用,S te l就是一个标准模板库standards template re,所以他就是一个标准模板库,后面他就是全部都是这样的一个模板,然后后面的人就可以基于这个标准模板库去使用模板。

然后这个模板呢,它有一个不好之处,总结来说,就是写模板的人跟用模板的人是分开的,它们之间是很难进行交流,甚至不知道彼此的。这个时候呢,你的写模板的人,他可能只提供了这么多部分的数据类型,你用模板的人呢,并不知道他写模板的人,基于这个函数,它提供了多少种你可以用的数据类型,所以这里就会出现一个问题就是。彼此之间不知道用模板的人可能不知道写模板的人,他给他提供了多少种可以用的数据类型,所以这个时候就需要有一些参数的约束,给他,就是说有一些信息通过一个编译器去传递,编译器告诉,告诉编译器,编译器之间进行传递,告诉你哪一些是可以,哪一些是不可以,这就是参数约束。

然后si Jia jia20版本它引入了很多特性,这些特性很多都是围绕着这个参数约束去增加的,就是希望增加一些特性,让你这个抽象的东西,彼此之间能够知道互相的约束,是什么,就是彼此本身是很难够知道的,就是想要通过一个参数的约束去传递,告诉对方我的这个订阅抽象,他的餐约束条件有哪些,这就是西加加二零,它的一些新增的特性的,主要的围绕解决的问题。

比如说这个C加加二零引入的request就是其中的一个参数约束,然后除此之外呢,还有一个细枝末写,就是一个export,这个export export关键字是专用于模板的,它类似于是对模板的一个声明,这个的话暂时可以先不用了解,知道就行,包括C加加二零引入了一些关于参数约束的一些关键字,比如request,不是request,是requires,比如这些关键字你大概知道就行,现在先可以不用理解,先不用了解。

就是现在可以先不用深入去理解。

异常处理机制 try catch机制

西加加中引入了try catch机制,就是异常处理机制,这个在Java里面也是有的,然后我们重点需要关注的是他为什么要有这个异常处理,也就是try catch机制。我的思考是有两点,其中我发现第一点并不正确,但是他会对你这个差cache的理解进行加深,第二点才是他真正为什么要有try catch的原因。第一点就是它的这个程序,他不想死,就是就说他如果你try catch的话,你就可以把你的那个try catch try里面的东西,然后就可以跳到那个catch里面去,你throw一个东西之后,你就可以跳到那个那个catch那里面去,你执行完catch之后呢,你就可以继续执行程序后面的东西。

你执行完这个东西之后,你执行完catch之后,你就可以继续去执行程序后面的内容,这样程序它就会继续跑下去,就不会突然间卡死中断掉。er c里面你如果是用衣服,然后判断他是否出现异常,然后呢,再一个返回,返回一个错误,这样的话他程序就在这里,就卡死了,就不会再执行下面的东西了,所以拆开他就保证了这个程序能够不死,然后就一直从上往下运行下去,然后他可以抓住一个异常catch异常,但是它程序不会卡,不会停住,它还会继续执行。

就好比你使用一个小程序或者一个软件,比如说QQ,他的如果你是他程序卡在一个地方,卡死之后呢,就就停止了,中途退出了,他的现象就是,比如说你打开了一个QQ里面的一个窗口,它就它就会弹出说你这个打开失败,然后直接就是直接QQ就退掉了,这个程序就死掉了,就是他可能没有打开窗口。

就是比如说你在QQ里面,你如果想打开一个窗口,你如果是没有程序,程序没有继续跑下去,那么就是他直接就闪退了,这QQ程序就直接死掉了。然后你如果是有一个异常机制的话,那么你打开这个窗口,可能这个窗口里面有bug,他可能就会踹开去,抓住了他,给你打印出来一个说此窗口不可使用,然后你点个确认之后,整个那个QQ程序还是可以继续运行的,只是在这个窗口这里有个bug用不了,但整个程序QQ还是可以继续运行的。

为什么要用try_catch机制

这是我的第一点,思考思考为什么他要用差cash,本质上来说,第一点的思考,他的原因是因为差catch,它可以程序不死,而C的那个衣服的话,程序会返回就死,直接死掉了。后面我发现这个可能不太准确,因为它的程序不死,是因为你没有返回,你如果C里面你也可以这么写,就是你的衣服她什么什么,然后你打印个什么东西,然后打印个出错,但是你不返回,你不返回的话,你也程序也是可以继续运行的。简单说,就是这个并不是引入try catch的主要原因,你就算不引入try catch,你用C语言的if判断,也可以直接让程序不死,只不过就是这样的话,你只要加一个,这样的话,你只要不返回它C语言里面的if程序,也可以不死,所以这个并不是主要的原因。

真正引入差cache的一个原因是为了实现他的一个代码,跟那个报错,就代码跟异常的一个完美的分离,这才是最关键的一点,就是你如果用了try catch,你的代码结构会非常的美观,你的把所有的cash都放到下面去,然后你的代码就放到上面去,这样的话你就可以实现了一个代码跟一个代码,跟一个那个立场的一个分离。如果你没有用try catch机制,那你每用每写一个函数,你这个代码你就要对它进行一个反,就进行一个评估,就是用if判断它会会是否会出现错误,然后做出下一步的反应,就是说你每用一个函数,你都要在后面加个if,这样的话,你的异常跟代码跟正常代码是不能分离的,每写一个正常代码都要写一个异常。

每写一个正常代码都要写一个异常,在后面衣服去判断他,但是你如果用了差catch机制,你正常代码是可以继续写下去的,然后你把正常代码写完之后,你在后面再写上一堆的一个catch,去catch他的错误,然后你再正常代码里面你多写一个输入的一个一个一个一行代码,你就自动的就可以输入到了后面的那个CAD里面去。总的来说,这才是真正的引入try catch的一个本质原因,它可以实现代码的一个美观性,简洁性,实现正常代码跟try catch异常的一个代码的一个分离,这样的话程序就看着就整洁了很多。

那这个差catch异常处理机制,它有一个through,它本质上是通过这个思路去找那个catch的,比如说你输入它里面你不同的情况,你会输入不同的数据类型,比如说你第一次你这个这个这个功能,这个函数它的异常呢,你输入的是int类型,你第二个函数的功能,你出现异常,你输入的是double类型,你第三个函数你出现异常,你输入的是一个float数据类型,然后你到后面的话,你到catch里面catch,它就会根据你,你的那个through的一的数据类型去分别进入到不同的cache中去。

首先你知道这个函数,它是一层一层去调用的,他可能有两三层,四五层,然后他可能在最底下的那一层呢,它只是抛出了一个异常,但是他并不catch,然后这个时候他就会程序就会层层的往外去推,你看你外面一层有没有开取,如果外面一层没有开去,在看在外面的一层,如果在外面一层还是没有开始,那在看在外面的一层,直到最后找到面面函数里面去。如果面函数里面还没有catch,那就说明你这个抛出来之后没有catch,最后就会慢,再往上一层就是操作系统了,那么操作系统就会认为你没有抛,你抛出了这个异常,但是你却没有catch它,那说明你这个程序就已经崩溃了,就已经死掉了,就是这样子。所以它是一个层层的往上去找它的catch,所以不一定在本函数里面就会有catch,它会往上面它的前一集去找。

为什么要有异常的throw列表
void func(void) throw(A,B,C);

然后就是还有一个情况,就是他你的血异常的人跟你这个开始异常的可能交流上面会有点不太方便,一般的话你就要,你如果这个函数里面你写了一些异常,你写了会产生一些什么异常,输入会输入一些什么异常,那你就要在函数的后面补上一个异常的一个,抛出异常的一个throw列表,有个思路列表之后,别人就知道你这里面会有什么异常,这样的话,人家在用你这个函数的时候才心中有数,知道你可能会抛出什么异常。

至于为什么他的那个你抛出异常,都可能会在本函数里面,没有开始,他异常会流到上一层函数,甚至上上层函数,再去开始他的这个异常呢,这个原因就是可能再抛出异常的时候呢,那个函数,它不知道你要对这个异常进行一个什么样的处理,比如说同样是一个处,被除数等于零的一个异常,可能有一些人他处理这个异常,他就直接。报报打印出一个东西,说不能这样用,可能有一些人他面对这个异常,他就想要处理成这个函数,直接就先停掉,先停止掉是吧,所以不同的人对不同的抛出的异常可能处理是不同的,所以这就是可能你无法在本函数里面就确定怎么对这异常进行处理,所以就先不在本函数进行catch,留给他的上一层,甚至上上层函数去处理他的这个异常。

这其中的一个最关最最典型的例子就是写标准库的那些人,他可能写标准库,那些人大多数都是只给你抛出一个异常,就是指给你输入一个异常,然后在那个函数的后面给你补上,我输入了什么样的异常。至于这个异常你怎么catch,那就是你的事了,因为写标准库的人不知道你要对我这个异常进行什么样的处理,是不是,所以他只能够是抛出了这个异常给你看,你最后你调用他的时候,你的上一层函数,乃至上上层函数。是怎么catch他的,Catch他之后怎么处理是吧,所以写标准库那些人,他是标准库里面基本上是没有catch的,他只是给你输入了异常,然后在函数的后函数外面补充告诉你,给你一个输入列表,输入列表能告诉你哦,我写标准库的时候,我会抛出什么异常,那么你用这标准库的人大概就心里有数,哦,你有你用了,这你出现你会可能会出现这些异常,我后面要怎么样,Catch你这些异常去怎么处理。

我后面怎么去catch你的异常,在我的上一层函数去去catch到你的这个异常,然后去进行处理。

自由存储区

徐佳佳里面多了一个自由存储区,它是专门跟六跟迪丽特相关的自由存储区,它也是属于堆的里面的东西,就是说自由存储区,它也是属于堆的那的一部分。

内存泄漏和内存碎片

然后C加加里面很大一部分的灵活性,还有一些风险性都是出现在这个镦镦的使用上,也就是说对内存的使用上,西家里面最经常出现的问题就是内存泄露和内存碎片,内存泄漏,这个我们现在写的一些短,比较短,然后比较小规模的代码是体现不出来的,因为他跑完自动就退出吗?所以你内存泄露你感受不到。但是如果是用C加加开发一些大型的服务器呀,这种大型的代码,它在后台要运行个一年两年甚至三年的,很长时间的都不关,那么这个时候内存泄露的风险就会体现出来了,比如说你这么久都不关,但是你如果,所以这时你如果出现内存泄露,你某一个力量忘记释放内存了,那么你内存就会一点一点的。

那么你内存就会一点一点的被吃掉,然后最后越来越久,越来越久,可能过个一段时间你的cpu就被搞搞死了,就是内存被吃完了,这就是长时间的一个运行之后,你如果内存泄漏没有处理好,长时间运行之后,这程序就会崩溃。

还有一个出现问题的地方,就是有关内存碎片的,这个就是比内存泄露更高级的一个话题了,内存碎片就是本质上就是说你反反复复的去六根迪利特,你反反复复的像这个操作系统去申请六申请迪利特,这样就造成了很多很多种频率的很多频次去申请了释放的内存,这样的话就会造成一种内存碎片,然后就这个东西会给那个操作系统的内存管理的效率增加很大的一个负担的,这个东西是更高级的话题了,后面深入再去说,就是内存碎片这方面的东西。

new和malloc的区别

关于六合malloc的区别,你可以理解为si家家里面之所以还会有一个malloc,是因为他为了要保持C的向下si的兼容,就说其实C加加里面现在可以,其实没有malloc都可以了,直接用六,然后我们后面就写C加加的时候呢,一般也是直接用六就行了,不用malloc的,有了六就不用malloc的,只不过你要很多东西,很多时候你要向C去兼容C加加,要兼容C,所以还保留了malloc。

然后六其实就是在它的它里面有包含malloc的,它是六,它这个是执行了,卖了之后他还多了一个构造函数,就说六,它比mile多的一个步骤,就是他在执行完买了之后,还多了一个构造函数的构造函数,就是你要构造一个对象的时候,所要所要使用的一个函数,然后这个函数就可以使得你六的那个东西。它可以初始化掉,所以这也就是六跟mylove的一个区别,Mylove的话,你申请一个内存,那里面的内存里面的那个值是随机的,它不会帮你清掉的,就类似于是一片荒地,但是六的话,它因为比mylove多了一个构造函数,所以构造函数那里,它可以把你申请一段内存里面的东西给初始化掉。

也就是说这个它的六它可以初始化,比如说你如果是一个inch,新批等于六,然后in te,那么它这个就会返回一个里面的地址里面的值为零的一个初始化的后的一个地址给你,然后你如果是6INCH,后面加个括号写上你的数字,那么这个就是你要初始化之后得到的那个数字,就你返回的那个地址,那个地址里面的纸就是你的括号里面的数字,你可以理解为如果不写括号,直接一个6INCH的话,那就是你的构造函数里面是默认了它的构造的初始化是为零的。

简单说就是六,他多比malloc多了一个构造函数,这时他可以初始化,而malloc是不可以的脉络可就直接就是申请一个那个内存,申请一个地址给你,然后malloc的话,它在C语言里面,它是一个是一个库来的,他在C库函数里面,但是六呢,直接就成为了C加加的一个关键字了,这也是他们的一个区别,还有一个区别就是。Mylove的话,它它返回值的类型是void的新类型的就是它它它没有一个固定的类型,你用的时候你要加个括号,把它强转,比如强转成int新类型你才能用,然后六的话呢,你写上一个六,那么它自动的就会认为你的这个返回值就是int新类型的。

new不能强转

然后六的这个特性呢,也决定了你是不能够像mylove那样是强转的,因为mylove是void星,它可以随便强转任何类型,但是你六的话,你是不能强转的,比如说你等于6INT的话,那你就只只它的返回值就是6INCH星了,就是int星了,而你6DOUBLE的话,它的返回值就是double星了,它是不像mylove可以强转的,也就是说它六它没有mylove那么自由了。

C++基本都用new,没必要用malloc

但是尽管如此,在C加加里面基本上都是用六了,不会用mylove的,就像前面刚刚说的,有了六就根本没有必要使用mylove了。C加加之所以要保留mylove,是因为它要保持对C的兼容,其实六能做的c mylove可能做了六已经帮它做出来了,而且做的比mylove还好,他帮你还初始化了,所以后面C加加写的时候基本都是用六了,而不用mylove了。

智能指针 多封装了一些东西,使其变得更智能

西加加的智能指针,简单来说就是它封装了一个类,这个类里面除了有指针,还有其他的一些其他的东西,比如说他有一个类,它这个类里面多了一个函数指针,函数指针指向的是他的一个自动回收的函数,指针指向的是他的一个回收,这个这个智能指针的那个地址,就是清理清理地址相关的一个函数指针,他把这些功能都放都打包成一个类,这叫智能指针。所以智能指针的话,它会省下一些功,省下一些事,你不用手动去回收啊,但是呢,它会消耗一定的资源,会比普通的程序员,用指针消耗更多的资源,为什么?因为比如说你直接用一指针,那你的那你就是一个四字节的地址嘛,那你如果用一个智能指针,那你就它它就打包这个类里面了,那类里面的话,它除了有指针,还有其他的,比如说你的一个函数指针去回收它的一个内存之外。

智能指针比普通指针消耗资源多

所以这种情况的话,智能指针它的消耗资源肯定就会比你普通定义一个指针消耗资源多,这就是智能指针。

智能指针除了这种情况,还有其他的几种情况,它不止这样一种实现方式,还有很多种实现方式,后面的话就会可以细看。

然后其中有一个s std auto,然后智能指针的那个东西,那东西是C99899的那一个特性,那个现在基本上已经废了,没有人用了,除了之外,反正这个后面细看就行了,现在还不用细看。

java垃圾回收机制

然后Java的话,它是一个,它有一个垃圾回收机制,它就比C加加的这智能指针更加离谱了,就你程序员完全不用管那个,那地址是怎么回收的,它Java里面有个Java虚拟机,J bm Java虚拟机,它帮你把这些东西都做好了,所以你程Java程序员,你直接这样用就行了。

就说Java,它有一个层级的,它其实Java的,你你你写的Java源代码,它是会把它编译成一个Java字节码,Java字节码,它是必须得要有Java虚拟机才能够使用的,所以它Java跟C加加是完全不在一个层次的,就C加加它是面向操作系统的,Java它是面向于Java虚拟机的,然后Java虚拟机本身就是用C或者C加加或者其他语言写出来的,所以Java跟C加加就不在一个层次上。

这里就是说了一个Java的一个跨平台性嘛,因为他Java它并不依赖于操作系统,Java它是依赖于Java虚拟机的,那么Java虚拟机呢,你只要有个Java虚拟机,那么它就可以用Java程序自解码就可以运行是吧?所以它其实依赖的不是操作系统,依赖是Java虚拟机,你只要在Linux Windows有个Java虚拟机,那么它就可以用Java,所以Java的跨平台性是体现在这里的。

java的效率不取决于程序员而是JVM虚拟机

阿扎保的话,你Java程序员,你是没有任何的一个能力可以对内存进行一个优化的,就说你程序员是没有权利的,就是你程序员的写出来代码效率高不高,程序员是无法决定的,真正决定的是扎把虚拟机,你的Java虚拟机越好,那么你程序员写的代码就效率就越高。所以真正取得效率是Java虚拟机,而不是程序员他写的东西,程序员他写的再好,他也无法改变效率的这个问题。因为取决于Java虚拟机呀,所以说安卓安卓,为什么基于Linux,他做了一个Java虚拟机出来,然后它的效率就,所以基于安卓做开发的那些人,那些程序员做Java,安卓程序员,他无法取决于效率,为什么?因为效率是取决于谷歌开发的那个安卓。

所以它的效率是取决于谷歌基于Linux开发出来的卓的这个操作系统,它的这个里面的那个Java虚拟机,它的一个优劣,它里面的那个Java虚拟机的效率并不高,所以很多人都会骂安卓,说安卓不好,所以就是因为它这个Java虚拟机不好,是这个原因,所以程序员他是无法无法改变这个现状的,他他没有权利,他没有这个能力去改变他这个效率问题,他写的再好代码也不行,因为真正决定你的效率也是Java虚拟机,然后你让Java垃圾回收机制也是在Java虚拟机里面去去实现的,不是程序员去实现的。

垃圾回收用的是GC线程

然后一般的Java的一个垃圾回收机制的话,就是它有一个巨溪县城,就是在ZB里面,你实现了一个GC线程,是Java虚拟机里面实现一个守护线程,这个肯定是用C后期在家或者其他原写的,不是用Java写的,然后这个车现成的话,就是他隔一段时间就会去进行一次,每运行一次,他就会把你的那个垃圾回收处理掉啦,基本上就是内存吗,就是你不用用没用了的内存,你要回收回来吗?否则就会内存泄露嘛。所以这个Java的一个垃圾回收就是用了,距县城去回收,每隔一段时间车县城就会回收。

垃圾回收的两种方法

对Java的垃圾回收机制,它有两点需要注意,第一个是什么时候需要回收,第二个是回收,哪些是需要回收的,什么时候需要回收,就根据线程有关了,你就有个算法嘛,算他是什么时候需要回收,什么时候需,需要执行这个车现成儿。第二点呢,就是它这个Java的这个,嗯,它会判断什么东西是得回收的,他的判断哪些是垃圾,哪些不是垃圾,是不是这里的话就是也是一个问题所在。这里呢,他就有一个算法,有两个算法,一个是引入引用计数法,第二个是可达性分析法,引用计数法简单说就是它会有一个引用。

引用计数法

引用计数法就是它会判断,它里面有个算法,它会判断你的引用,对于这个这个内存的一个引用次数,如果引用多了就加就是正的,如果引用少了,那他它就会一直一直减,只要减到负,那么它就通过这个引用技术的一个情况来判断你这个到底是不是一个垃圾,如果引用的少了,变成负了,那它就是垃圾,就回收。

可达性分析法

然后第二个就是可达性分析法,可达性分析法就是说他一个函数或者一个内存,它是有前后链接的,如果他前后链接通透的,一直都是我用了你,你用了我,我用了你用了我,他有一条线呢是通透了,那么就说明他这个内存是要用的,还不用回收,还不是垃圾。但是如果你这个内存它的前后不通透了,比如你用了我用了,你用了我,但是其中前面东西没有人用了,那么它这个前面就没有人用了的话,那它就是断了断了的话,就不通透了。他前面有断掉了,所以他这个可能就是没有,没有用了的,已经没有用了的,他前面比如说a用了B,但是没有人用a,那么这个时候呢,就是断了的,一旦断了的话,就说明他就没有人用,那么它就是垃圾了,这就是可达性分析法,通过可达性分析法就可以实现判断它是垃圾去回收。

这就是整个一个Java的一个关于他的一个从,从他的出现,就从她的一个起源,到它的一个展现到我们的面前的一个整个一个流程,就它是其实是从先是从操作系统,再到一个Java虚拟机,再到一个Java字节码,再到一个Java源代码了,所以他Java,他跟操作系统还差的远呢,它中间是用操Java虚拟机的,Java虚拟机本身是操作系统,用C加加写出来了,所以Java跟C加加不在一个层次上,Java的话,前面还有个Java虚拟机才能到操作系统,所以就是这样子。然后Java的回收机制的话,刚刚前面也说了,他有一些东西在里面,我前面已经说了,现在就是基本上已经讲完了,就是这么多东西了。

所以总的来讲就是有三个阶段,就si阶段,还有C加加C阶段和传统的C加加阶段,它是没有任何的一个介入的,对于内存没有任何介入,完全靠程序员手动,然后第二个阶段就是C加加里面,它引入了一些些一小点的一个智能阶段,就是一个智能指针,然后这个智能指针,指针呢,它会有一定的帮助程序员去进行内存管理,但是大部分还是要程序员自己手动操作的,你像我刚说他就就就是一个打包成一个类吗。类里面多一个函数指针,函数指针里面指向的功能就是去进行垃圾回收,去进行一个内存回收嘛,但它其实大部分还是要程序员去做的,这是C加加的一个高级的一个阶段。然后还有一个更高阶段,就是Java阶段,Java就纯粹就是把内存回收、内存管理全部交给了JPN全部交给了那个,那个一个全部,不用程序员操心。

就是Java,他把所有的东西都已经内存管理,东西都都把都不给程序员做,程序员呢,只是负责写代码,他不用关心内存了,内存的管理啊,内存泄露的东西全部交给Java虚拟机这边去做的呢,就是通过操作系统慢慢演变过来,通过CC加加写出来,实现一个东西,就是这样子,整体来说就这样子。到了第三个Java阶段的话,这这些语言,它完全就是不需要程序员去对内存进行管理的,比如说Java、西沙华、python的这些。它基本上就是有一个,它就是用CC加加实现那个g bn Java虚拟机嘛,C shop肯定也会有一个类似的一个GBN之类东西,Python的话也是,凡是这种东西的话,就是有这样东西。这就像这也就是叫一种解释型语言,解释型语言就是这样做出来的,它不是基于操作系统直接来的,它是有个JBN的,先用操作系统CC加加开发出个GPN,然后让你去用,其实c Java啊,然后C韶华,Python都是这一类东西。

就是都是这一类形,通过操作系统开发出了一个用来解释你的这个这个语言的个东西,然后基于你这个解释的语言的东西,然后你去开发语言,所以他重点提升效率,然后对内存进行管理,是对于你这个语言进行解释的那个程序,也这个就是在Java里面,就是在JVM,虚拟机在拍摄里面可能就是体现别的代替效果,肯定是就可能就体现别人,但他就跟操作系统就已经是不在同一个层次的,C跟C加加,就是直接用操作系统,可能他的那个解释解释东西,就是用C加加写出来的。他解释,比如说GVNJVN解释的那些东西就用CC来写出来,所以这其实是两个层次的东西,所以到更高级啊,Java啊,Java啊,然后拍成这些,它就是一个程序,也完全不用管了,不用管内存管理啊,把它交给你对这个语言进行解释的那东西进行处理,是这样子,它层次就划分的很很远了。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/950854.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号