CSDN-VC编程经验总结

CSDNVC编程经验总结C++学习要点1.传指针时，我们可以通过指针来修改它在外部所指向的内容。但如果要修改外部指针所指向的对象是不可能的。例如传递外部指针到函数内来分配空间，必须传递指针的指针或指针的引用。2.charcarry[10]={0};编译器会将其后所有的东西都置0；3.函数返值为const时，返的东西付给一个类型相同的标示后其不能为左值；4.constinti;intconsti;intconsti;前两个功能相同， 说明 关于失联党员情况说明岗位说明总经理岗位说明书会计岗位说明书行政主管岗位说明书 I所指向的内容不变；最后一个说明指针指向的地址不变，但内容可变。5.类中的const成员函数。定义为在原型后加const。常量函数不能修改类中的任何属性。但有两种方法可以修改。a){myclass）this>member1=values;}b)将一个成员定义成mutable即可被常量函数修改。6.类中的常量const类型的，不能在类中被用来定义数组。而enum{ONE=100;TWO=2};定义的ONE、TWO却可以。通常的enum定义的置分配问题：enumA{L=9,Z};此时Z的值为10。7.用const定义的int可用来开辟数组，但const定义的常量数组中的元素，不能用来定义数组。8.用sizeof计算变量的空间，如果是数组，按实际空间返；常量字符串实际上是在静态内存区开辟的变量）sizeof返比实际长度加一。如果是指针则不考虑它指向的空间大小，仅仅返指针类型的大小。如果用sizeof计算函数的行参，即使是属组也仅仅返一个相关类型指针的大小。9.形如intiarray[]={12,124,433};编译器会自动给iarray分配3个元素的长度。元素长度的个数计算公式为sizeof(iarray)sizeof(iarray)。10.拷贝构造函数：当行参和实参结合时，如果是复杂对象的传值类型，则调用拷贝构造函数生成一个临时对象作为实参，退出函数时，临时对象被调用析构函数释放。当返值是复杂对象是，也是调用拷贝构造函数来赋值。这就出现构造函数和析构函数被调用次数不相等的情况。拷贝构造函数的原型为A(A)，我们可在类中重载。缺省的拷贝构造函数是使用位bit）拷贝方法：浅层拷贝，不拷贝指针指向的内容）。11.volatile类型的变量告诉编译器，本变量不需要进行代码优化。在多线程的应用中，我们如果读入一个变量到寄存器，此时时间片到期，去处理其他线程了，在重新获得处理机时，volatile类型告诉处理机，重新从变量读取数据到寄存器，而不是用寄存器数据直接处理，这样可以防止脏数据。12.class和struct在一定程度上有相同的功能，只不过前者缺省的成员是私有的，后者在缺省时成员为共有的。故而class不是c++必需的保留字13.c和c++编译器，对相同的函数名编译后生成的相同的标示不同，故而在引用c的库文件时必须使用extern“C”告诉编译器，它是c的函数，按c的规则编译。通常我们使用的标准头文件已被处理过。14.include“filename”；include<filename>，前者先在当前 目录 工贸企业有限空间作业目录特种设备作业人员作业种类与目录特种设备作业人员目录1类医疗器械目录高值医用耗材参考目录 下寻找文件，如果找不到再到系统规定的路径下找，后者直接到系统规定的路径下找。15.任何地方分配的静态变量static）,其生命周期和主进程相同。第二次定义一个已存在的static变量，对变量的内用无影响，但它的可见范围只在定义的范围内。考研曾作错！）(从静态变量的特性不难理解，类中的static类型是所有对象共享的)16.内联函数inline）在实现上实际和宏类似，在内联函数出现的地方将函数展开来避免函数调用时的出栈、如栈，提高效率。但内联函数的代价是：代码增大。inline函数适合成员函数和自由函数。在类中实现的函数自动为内联函数。inline必须定义到函数的实现上，例如：inlineintPlusOne(int)是无效的。友元函数在类的体内被实现自动变为内联函数。17.include<iostream.h>defineDEBUG(X)cout<<X=<<X<<endl其中的X 表 关于同志近三年现实表现材料材料类招标技术评分表图表与交易pdf视力表打印pdf用图表说话 pdf 示X被当作字符串输出。18.assert(0!=0);如果assert中的条件为假，则运行期间退出程序，且报告出错代码的行号。include<assert.h>）19.静态对象在main结束或exit()被调用时才调用自身的析构函数。这意味着，在对象的析构函数中调用exit()是很危险的，有可能进入一个死循环中。调用abort()来退出函数，静态对象的析构函数并不会被调用。我们可以用atexit()来指定跳出main或调用exit时要执行的操作，用atexit注册的函数，可以在所有对象的析构函数之前调用。voidexitfn2(void){printf(Exitfunction2called\n);}处理函数atexit(exitfn2);20.全局变量实际上用的是静态存储。静态变量的构造是在进入main之前调用的，在main结束时调用它的析构函数。变量的名字由小范围c++而言）：.cppinta;静态变量,但为externinta;即它是全局的，外部可见的staticintb;静态变量,static和extern相反，只在.cpp中有效，对其他单元文件）是不可见的。函数的定义和上面相同。main(){}类的静态成员变量可以如下赋值：intX::s=23;在.cpp中，无论公私都可以）21.名字空间(namespace):定义一个名字空间，然后使用unsing就可以将当前的类型上下文转换名字空间所定地的.namespacemath{enumsign{positive,negative};classinteger{inti；signs;public:interger(intI=0):i(i){}signSign(){}..};endclassintergerA,B,C;intergerdivide(interger,interger);}no;voidq(){usingnamespacemath;intergerA;hidesmath::AA.Sign(negative);Math::A.Sign(positive);}22.一般对于函数flaotf(inta,intb);某些c++编译器编译后生成fintint的名字，有些c编译器则生成f的名字。故在c++中链接c的库函数时要用extern“C”告诉编译器，按c的规则来编译函数。类似的还有extern“C”{include“myhead.h”},c++还支持extern“C++”{}.23.在函数调用时，传引用也是将指针压栈。24.构造函数、析构函数、赋值构造函数、重载的=，四者的调用顺序：(三种函数都已实现)a)Xx;Xa=x;result:X:constructX:copystructb)Xx;Xa;a=x;Result:X:constructX:constructX:copystruoperator=X:destruct如果没有赋值构造函数则结果：X:constructX:constructoperator=X:destruct如果直接Xa=x;这不掉用一般的构造函数，调用复制构造函数）指向类的成员函数的指针：设intX::a(void){}Xx;int(X::pf)(void)=X::a;(x.pf)();指向成员变量的指针：设inti;是X的成员变量intX::pm=X::i;Xx;CSDNVC编程经验总结C++深度探索系列：智能指针(SmartPointer)一、剖析C++标准库智能指针(std::autoptr)1.DoyouSmartPointer?2.std::autoptr的设计原理3.std::autoptr高级使用指南4.你是否觉得std::autoptr还不够完美?二、C++条件,寻找构造更强大的智能指针(SmartPointer)的策略1.支持引用记数的多种设计策略2.支持处理多种资源3.支持Subclassing4.支持多线程条件下,线程安全的多种设计策略5.其它多种特殊要求下,再构造三、GenericProgramming基础技术和SmartPointer1.首处理资源中的Traits技术2.首多线程支持的设计四、COM实现中,SmartPointer设计原理五、著名C++库(标准和非标准)中的SmartPointer现状一、剖析C++标准库智能指针(std::autoptr)1.DoyouSmartPointer?SmartPointer,中文名：智能指针,舶来品?不可否认,资源泄露(resourceleak)曾经是C++程序的一大噩梦.垃圾收机制(GarbageCollection)一时颇受注目.然而垃圾自动收机制并不能满足内存管理的即时性和可视性,往往使高傲的程序设计者感到不自在.况且,C++实现没有引入这种机制.在探索中,C++程序员创造了锋利的SmartPointer.一定程度上,解决了资源泄露问题.也许,经常的,你会写这样的代码：x拟为class:classx{public:intmIdata;public:x(intmPARAMin):mIdata(mPARAMin){}voidprint(){cout<<mIdata<<endl;}..}voidfook(){xmPTRx=newA(mPARAMin);mPTRx>DoSomething();2deletemPTRx;}是的,这里可能没什么问题.可在复杂、N行、mPTRclassobj所指对象生命周期要求较长的情况下,你能保证你不会忘记deletemPTRclassobj吗?生活中,我们往往不应该有太多的口头保证,我们需要做些真正有用的东西.还有一个更敏感的问题：异常.假如在2方法执行期异常发生,函数执行终止,那么new出的对象就会泄露.于是,你可能会说：那么就捕获异常来保证安全性好了.你写这样的程式：voidfook(){AmPTRx=newA(mPARAMin);try{mPTRx>DoSomething();}catch(..){deletemPTRx;throw;}deletemPTRx;}哦!天哪!想象一下,你的系统,是否会象专为捕获异常而设计的.一天,有人给你建议:用SmartPointer,那很安全..你可以这样重写你的程序：voidfook(){autoptr<x>mSMPTRx(newx(mPARAMin));mSMPTRx>DoSomething();}OK!你不太相信.不用delete吗?是的.不用整天提心吊胆的问自己:我全部delete了吗?,而且比你的delete策略更安全.然后,还有人告诉你,可以这样用呢：ok1.autoptr<x>mSMPTR1(newx(mPARAMin));autoptr<x>mSMPTR2(mSMPTR1);2Maybeyoucancode2likethis:autoptr<x>mSMPTR2;mSMPTR2=mSMPTR1;ok2.autoptr<int>mSMPTR1(newint(32));ok3.autoptr<int>mSMPTR1;mSMPTR1=autoptr<int>(newint(100));也可以：autoptr<int>mSMPTR1(autoptr<int>(newint(100)));ok4.autoptr<x>mSMPTR1(newx(mPARAMin));mSMPTR1.reset(newx(mPARAMin1));ok5.autoptr<x>mSMPTR1(newx(mPARAMin));autoptr<x>mSMPTR2(mSMPTR.release());cout<<(mSMPTR2).mIdata<<endl;ok6.autoptr<int>fook(){returnauto<int>(newint(100));}ok7.andsoon但不可这样用：no1.charchrarray=newchar[100];strcpy(chrarray,Iamprogramming.);autoptr<char>mSMPTRchrptr(chrarray);autoptr并不可帮你管理数组资源no2.vector<autoptr<x>>mVECsmptr;mVECsmptr.pushback(autoptr<int>(newint(100)));autoptr并不适合STL内容.no3.constautoptr<x>mSMPTR1(newx(100));autoptr<x>mSMPTR(newx(200));no4.xmOBJx(300);autoptr<x>mSMPTR(mOBJx);no5xmPTR=newx(100);autoptr<x>mSMPTR=mpTR;no6.andsoon预先提及所有权的问题,以便下面带着疑问剖析代码?power1.autoptr<x>mSMPTR1(newx(100));autoptr<x>mSMPTR2=mSMPTR1;mSMPTR2>print();输出：100.mSMPTR1>print();!!非法的.power2.autoptr<x>mSMPTR(newx(100));autoptr<x>returnfun(autoptr<x>mSMPTRin){returnmSMPTRin;}autoptr<x>=returnfun(mSMPTR);5在上面的5中,我要告诉你对象所有权转移了两次.什么叫对象所有权呢?2.std::autoptr的设计原理上面的一片正确用法,它们在干些什么?一片非法,它们犯了什么罪?一片什么所有权转移,它的内部机智是什么?哦!一头雾水?下面我们就来剖析其实现机制.基础知识：a.智能指针的关键技术：在于构造栈上对象的生命期控制堆上构造的对象的生命期.因为在智能指针的内部,存储着堆对象的指针,而且在构析函数中调用delete行为.大致机构如下：xmPTRx=newx(100);1template<typenameT>autoptr{private:TmPTR;维护指向堆对象的指针,在autoptr定位后.它应该指向1构造的对象,即拥有所有权.auto(){deletemPTR;}.}b.所有权转移之说上面曾有一非法的程式片段如下：autoptr<x>mSMPTR1(newx(100));autoptr<x>mSMPTR2=mSMPTR1;mSMPTR2>print();输出：100.mSMPTR1>print();!!非法的.按常理来说,mSMPTR>print();怎么是非法的呢?那是因为本来,mSMPTR1维护指向newx(100)的指针,可是mSMPTR2=mSMPTR1;autoptr内部机制使得mSMPTR1将对象的地址传给mSMPTR2,而将自己的对象指针置为0.那么自然mSMPTR>print();失败.这里程序设计者要负明显的职责的.那么autoptr为什么采取这样的策略：保证所有权的单一性.亦保证了系统安全性.如果多个有全权的autoptr维护一个对象,那么在你消除一个autoptr时,将导致多个autoptr的潜在危险.智能指针2:下面我们以SGISTL的autoptr设计为样本(去掉了无关 分析 定性数据统计分析pdf销售业绩分析模板建筑结构震害分析销售进度分析表京东商城竞争战略分析 的宏),来剖析其原理.1template<classTp>classautoptr{2private:3TpMptr;定义将维护堆对象的指针4public:5typedefTpelementtype;相关类型定义6explicitautoptr(Tpp=0)STLNOTHROW:Mptr(p){}7autoptr(autoptra)STLNOTHROW:Mptr(a.release()){}8template<classTp1>autoptr(autoptr<Tp1>a)STLNOTHROW:Mptr(a.release()){}6、7、8是autoptr构造函数的三个版本.6注释：传入对象的指针,构造autoptr.explicit关键字:禁止隐式转换.这就是ok2正确,而no5(隐式转换)错误的原因.7注释：拷贝构造函数.传入autoptr实例,构造autoptr.ok1、ok3使用了这个构造式.它是一个很关键的构造函数,在具体情况下,我们再分析8注释：autoptr的 模板 个人简介word模板免费下载关于员工迟到处罚通告模板康奈尔office模板下载康奈尔 笔记本 模板 下载软件方案模板免费下载 成员,可在继承对象重载的基础上,实现特殊功能.举例：classA{public:virtualvoidfook(){cout<<Iamprogramming<<endl;.};classB:publicA{virtualvoidfook(){cout<<Iamworking<<endl;..};autoptr<A>mSMPTRa(newA(33));实质：autoptr<B>mSMPTRb(mSMPTRa);基类的指针可以赋给派生类的指针autoptr<B>mSMPTRb(newB(44));实质：autoptr<A>mSMPTRa(mSMPTRb);派生类的指针不可赋给基类的指针autoptr<A>mSMPTRa(newB(33));ok!mSMPTRa>fook()将调用派生类B的fook()mSMPTRa>A::fook()将调用基类A的fook()autoptr<B>mSMPTRb(newA(33));wrong!9autoptroperator=(autoptra)STLNOTHROW{10if(a!=this){deleteMptr;Mptr=a.release();}11returnthis;12}13template<classTp1>14autoptroperator=(autoptr<Tp1>a)STLNOTHROW{15if(a.get()!=this>get()){deleteMptr;Mptr=a.release();}16returnthis;16}916两个版本的指派函数.deleteMptr;在指派前,销毁原维护的对象.a.release();release操作,详细代码参见2023.用于this获得被指派对象,且将原维护autoptr置空.no3使用了第一种指派.而权限转移正是a.release()的结果.17autoptr()STLNOTHROW{deleteMptr;}构析函数.消除对象.注意这里对对象的要求!17Tpoperator()constSTLNOTHROW{returnMptr;}18Tpoperator>()constSTLNOTHROW{returnMptr;}19Tpget()constSTLNOTHROW{returnMptr;}操作符重载.17注释：提领操作(dereference),获得对象.见ok5用法.18注释：成员运算符重载,返对象指针.19注释：普通成员函数.作用同于重载>运算符20Tprelease()STLNOTHROW{21Tptmp=Mptr;22Mptr=0;23returntmp;}上面已经详解24voidreset(Tpp=0)STLNOTHROW{25deleteMptr;26Mptr=p;}传入对象指针,改变autoptr维护的对象且迫使autoptr消除原来维护的对象见ok3用法.AccordingtotheC++standard,theseconversionsarerequired.Mostpresentdaycompilers,however,donotenforcethatrequirementand,infact,mostpresentdaycompilersdonotsupportthelanguagefeaturesthattheseconversionsrelyon.下面这片段用于类型转化,目前没有任何编译器支持具体技术细节不诉.ifdefSGISTLUSEAUTOPTRCONVERSIONS27private:28template<classTp1>29structautoptrref{Tp1Mptr;autoptrref(Tp1p):Mptr(p){}};30public:31autoptr(autoptrref<Tp>ref)STLNOTHROW:Mptr(ref.Mptr){}32template<classTp1>33operatorautoptrref<Tp1>()STLNOTHROW34{returnautoptrref<Tp>(this>release());}35template<classTp1>operatorautoptr<Tp1>()STLNOTHROW36{returnautoptr<Tp1>(this>release());}37endifSGISTLUSEAUTOPTRCONVERSIONS38};OK!就是这样了.正如上面原理介绍处叙说,你需要正视两大特性：1.构造栈对象的生命期控制堆上构造的对象的生命期2.通过release来保证autoptr对对象的独权.在我们对源码分析的基础上,重点看看：no系列错误在何处?no1.我们看到构析函数template<classTp>autoptr()STLNOTHROW{deleteMptr;}所以它不能维护数组,维护数组需要操作：delete[]Mptr;no2.先提部分vector和autoptr代码：a.提autoptr代码autoptr(autoptra)STLNOTHROW:Mptr(a.release()){}b.提vector代码Part1:voidpushback(constTpx){if(Mfinish!=Mendofstorage){construct(Mfinish,x);++Mfinish;}elseMinsertaux(end(),x);}Part2:template<classT1,classT2>inlinevoidconstruct(T1p,++++++++++++++++++++++++++++++++constT2value){+++++++++++++++++++++++++++++++++new(p)T1(value);+++++++++++++++++++++++++++++++++}Part3.template<classTp,classAlloc>voidvector<Tp,Alloc>::Minsertaux(iteratorposition,++++++++++++++++++++++++++++++++constTpx)++++++++++++++++++++++++++++++++++{if(Mfinish!=Mendofstorage){construct(Mfinish,(Mfinish1));++Mfinish;++++++++++++++++++++++++++++++++Tpxcopy=x;+++++++++++++++++++++++++++++++++copybackward(position,Mfinish2,Mfinish1);position=xcopy;}else{constsizetypeoldsize=size();constsizetypelen=oldsize!=0?2oldsize:1;iteratornewstart=Mallocate(len);iteratornewfinish=newstart;STLTRY{newfinish=uninitializedcopy(Mstart,position,newstart);construct(newfinish,x);++newfinish;newfinish=uninitializedcopy(position,Mfinish,newfinish);}STLUNWIND((destroy(newstart,newfinish),Mdeallocate(newstart,len)));destroy(begin(),end());Mdeallocate(Mstart,MendofstorageMstart);Mstart=newstart;Mfinish=newfinish;Mendofstorage=newstart+len;}}智能指针3:从提取的vector代码,Part1可看出,pushback的操作行为.兵分两路,可是再向下看,你会发现,无一例外,都通过constTp进行拷贝行为,那么从autoptr提出的片段就派上用场了.可你知道的,autoptr总是坚持对对象的独权.那必须修改原来维护的对象,而vector行为要求constTp,这样自然会产生问题.一般编译器是可以发觉这种错误的.其实,STL所有的容器类都采用constTp策略.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++看了sutter和Josuttis的两篇文章中,都提及：++STL容器不支持autoptr原因在于copy的对象只是获得所有权的对象,++这种对象不符合STL的要求.可是本人总感觉即时不是真正的复制对象,++但我用vector<autoptr<x>>的目的就在于维护对象,并不在乎++所谓的完全对象.而且我用自己写的SmartPointer配合STL容器工作,++很正常.那需要注意的仅仅是const问题.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++no3.这个也是autoptr隐含的所有权问题引起的.constautoptr不允许修改.随便提及：const对象不代表对象一点不可以改变.在两种const语义下,都有方法修改对象或对象内部指针维护的对象或其它资源.no4.再看autoptr的构析函数.delete不可以消除栈上资源.no5.依赖传入对象指针的构造函数被声明为explicit,禁止隐式转换.3.autoptr高级使用指南a.类成员autoptr,禁止构造函数以构建完全对象Programme1:structStructx{intmIdata;charmCHRdata;andsoon};出于对象编程的理念,我们将Structx打造成包裹类：classStructWrapper{private:StructxmSTRTxptr;public:StructWrapper():mSTRTxptr(newStructx){}StructWrapper(){deletemSMRTxptr;}public:voidSoperator1(){针对Structx对象的特性操作}voidSoperator2(){针对Structx对象的特性操作}andsoon};Programme2:classStructWrapper{private:autoptr<Structx>mSMPTRx;public:StructWrapper():mSMPTRAx(newStructx){}public:voidSoperator1(){针对Structx对象的特性操作}voidSoperator2(){针对Structx对象的特性操作}andsoon};Programme3:StructWrapper::StructWrapper(constStructWrapperother):MSMPTRx(newStruct(other.mSMPTRx)){}StructWrapperStructWrapper::operator=(constStructWrapperother){mSMPTRx=other.mSMPTRx;};处于对构建于堆中的对象(newStructx)智能维护的需要.我们将programme1改造为programme2：不错,对象是可以智能维护了.对于包裹类(StructWrapper)你是否会有这样的构造或指派操作：StructWrappermSMPTRWrapper2(mSMPTRWrapper1);StructWrappermSMPTRWrapper2=mSMPTRWrapper1;那么请注意：当你坦然的来一个：MSMPTRWrapper1>Soperator1();的时候,系统崩溃了.不必惊讶,所有权还是所有权问题.问一下自己：当programme2默认拷贝构造函数作用时,又调用了autoptr的默认构造函数,那么autoptr所有的默认行为都遵循独权策略.对,就这样.mSMPTRWrapper1的对象所有权转移给了mSMPTRWrapper2.MSMPTRWrapper1>Soperator1();那么操作变成了在NULL上的.哦!系统不崩溃才怪.那么你需要想,programme3那样利用autoptr的提领操作符自己的构造完全对象.b.利用const关键字,防止不经意的权限转移从上面的叙述,你可看出,所有权转移到处可以酿成大祸.而对于一般应用来说,独权又是很好的安全性策略.那么我们就用const来修饰autoptr,禁止不经意的错误.当然上面提及：并不代表autoptr是不可修改的.处于需要,从两种const语义,你都可实现修改.然,你还希望在函数传入传出autoptr那么你可传递autoptr的引用,那就万无一失了:voidfook(constautoptr<x>mPARAMin);在返后赋予其它时,使用引用是不行的.你得用指针.因为引用无论作为lvalue还是rvaluev,都会调用构造或指派函数.4.你是否觉得std::autoptr还不够完美在实践中,std::autoptr能满足你的需求吗?AndreiAlexandrescu在一篇文章中,提及：有关SmartPointer的技术就像巫术.SmartPointer作为C++垃圾收机制的核心,它必须足够强大的、具有工业强度和安全性.但为了可一劳永逸我们还需要披荆斩棘继续探索.下面在需求层面上,我们思索一下我们的智能指针还需要些什么?a.std::autoptr能够处理数组吗?我们可以用智能指针来管理其它的资源吗?譬如一个线程句柄、一个文件句柄andsoon!b.对于我们的对象真的永远实行独权政策吗?c.Our智能指针还需要在继承和虚拟层面上发挥威力!d.往往,需要扩展Our智能指针的功能成员函数来满足动态的需要!e.也许,你需要的还很多.[下续]二、C++条件,寻找构造更强大的智能指针(SmartPointer)的策略1.支持引用记数的多种设计策略2.支持处理多种资源3.支持Subclassing4.支持多线程条件下,线程安全的多种设计策略5.其它多种特殊要求下,再构造三、GenericProgramming基础技术和SmartPointer1.首处理资源中的Traits技术2.首多线程支持的设计四、COM实现中,SmartPointer设计原理五、著名C++库(标准和非标准)中的SmartPointer现状CSDNVC编程经验总结C++深度探索系列：智能指针(SmartPointer)一、剖析C++标准库智能指针(std::autoptr)1.DoyouSmartPointer?2.std::autoptr的设计原理3.std::autoptr高级使用指南4.你是否觉得std::autoptr还不够完美?二、C++条件,寻找构造更强大的智能指针(SmartPointer)的策略1.支持引用记数的多种设计策略2.支持处理多种资源3.支持Subclassing4.支持多线程条件下,线程安全的多种设计策略5.其它多种特殊要求下,再构造三、GenericProgramming基础技术和SmartPointer1.首处理资源中的Traits技术2.首多线程支持的设计四、COM实现中,SmartPointer设计原理五、著名C++库(标准和非标准)中的SmartPointer现状一、剖析C++标准库智能指针(std::autoptr)1.DoyouSmartPointer?SmartPointer,中文名：智能指针,舶来品?不可否认,资源泄露(resourceleak)曾经是C++程序的一大噩梦.垃圾收机制(GarbageCollection)一时颇受注目.然而垃圾自动收机制并不能满足内存管理的即时性和可视性,往往使高傲的程序设计者感到不自在.况且,C++实现没有引入这种机制.在探索中,C++程序员创造了锋利的SmartPointer.一定程度上,解决了资源泄露问题.也许,经常的,你会写这样的代码：x拟为class:classx{public:intmIdata;public:x(intmPARAMin):mIdata(mPARAMin){}voidprint(){cout<<mIdata<<endl;}..}voidfook(){xmPTRx=newA(mPARAMin);mPTRx>DoSomething();2deletemPTRx;}是的,这里可能没什么问题.可在复杂、N行、mPTRclassobj所指对象生命周期要求较长的情况下,你能保证你不会忘记deletemPTRclassobj吗?生活中,我们往往不应该有太多的口头保证,我们需要做些真正有用的东西.还有一个更敏感的问题：异常.假如在2方法执行期异常发生,函数执行终止,那么new出的对象就会泄露.于是,你可能会说：那么就捕获异常来保证安全性好了.你写这样的程式：voidfook(){AmPTRx=newA(mPARAMin);try{mPTRx>DoSomething();}catch(..){deletemPTRx;throw;}deletemPTRx;}哦!天哪!想象一下,你的系统,是否会象专为捕获异常而设计的.一天,有人给你建议:用SmartPointer,那很安全..你可以这样重写你的程序：voidfook(){autoptr<x>mSMPTRx(newx(mPARAMin));mSMPTRx>DoSomething();}OK!你不太相信.不用delete吗?是的.不用整天提心吊胆的问自己:我全部delete了吗?,而且比你的delete策略更安全.然后,还有人告诉你,可以这样用呢：ok1.autoptr<x>mSMPTR1(newx(mPARAMin));autoptr<x>mSMPTR2(mSMPTR1);2Maybeyoucancode2likethis:autoptr<x>mSMPTR2;mSMPTR2=mSMPTR1;ok2.autoptr<int>mSMPTR1(newint(32));ok3.autoptr<int>mSMPTR1;mSMPTR1=autoptr<int>(newint(100));也可以：autoptr<int>mSMPTR1(autoptr<int>(newint(100)));ok4.autoptr<x>mSMPTR1(newx(mPARAMin));mSMPTR1.reset(newx(mPARAMin1));ok5.autoptr<x>mSMPTR1(newx(mPARAMin));autoptr<x>mSMPTR2(mSMPTR.release());cout<<(mSMPTR2).mIdata<<endl;ok6.autoptr<int>fook(){returnauto<int>(newint(100));}ok7.andsoon但不可这样用：no1.charchrarray=newchar[100];strcpy(chrarray,Iamprogramming.);autoptr<char>mSMPTRchrptr(chrarray);autoptr并不可帮你管理数组资源no2.vector<autoptr<x>>mVECsmptr;mVECsmptr.pushback(autoptr<int>(newint(100)));autoptr并不适合STL内容.no3.constautoptr<x>mSMPTR1(newx(100));autoptr<x>mSMPTR(newx(200));no4.xmOBJx(300);autoptr<x>mSMPTR(mOBJx);no5xmPTR=newx(100);autoptr<x>mSMPTR=mpTR;no6.andsoon预先提及所有权的问题,以便下面带着疑问剖析代码?power1.autoptr<x>mSMPTR1(newx(100));autoptr<x>mSMPTR2=mSMPTR1;mSMPTR2>print();输出：100.mSMPTR1>print();!!非法的.power2.autoptr<x>mSMPTR(newx(100));autoptr<x>returnfun(autoptr<x>mSMPTRin){returnmSMPTRin;}autoptr<x>=returnfun(mSMPTR);5在上面的5中,我要告诉你对象所有权转移了两次.什么叫对象所有权呢?2.std::autoptr的设计原理上面的一片正确用法,它们在干些什么?一片非法,它们犯了什么罪?一片什么所有权转移,它的内部机智是什么?哦!一头雾水?下面我们就来剖析其实现机制.基础知识：a.智能指针的关键技术：在于构造栈上对象的生命期控制堆上构造的对象的生命期.因为在智能指针的内部,存储着堆对象的指针,而且在构析函数中调用delete行为.大致机构如下：xmPTRx=newx(100);1template<typenameT>autoptr{private:TmPTR;维护指向堆对象的指针,在autoptr定位后.它应该指向1构造的对象,即拥有所有权.auto(){deletemPTR;}.}b.所有权转移之说上面曾有一非法的程式片段如下：autoptr<x>mSMPTR1(newx(100));autoptr<x>mSMPTR2=mSMPTR1;mSMPTR2>print();输出：100.mSMPTR1>print();!!非法的.按常理来说,mSMPTR>print();怎么是非法的呢?那是因为本来,mSMPTR1维护指向newx(100)的指针,可是mSMPTR2=mSMPTR1;autoptr内部机制使得mSMPTR1将对象的地址传给mSMPTR2,而将自己的对象指针置为0.那么自然mSMPTR>print();失败.这里程序设计者要负明显的职责的.那么autoptr为什么采取这样的策略：保证所有权的单一性.亦保证了系统安全性.如果多个有全权的autoptr维护一个对象,那么在你消除一个autoptr时,将导致多个autoptr的潜在危险.智能指针2:下面我们以SGISTL的autoptr设计为样本(去掉了无关分析的宏),来剖析其原理.1template<classTp>classautoptr{2private:3TpMptr;定义将维护堆对象的指针4public:5typedefTpelementtype;相关类型定义6explicitautoptr(Tpp=0)STLNOTHROW:Mptr(p){}7autoptr(autoptra)STLNOTHROW:Mptr(a.release()){}8template<classTp1>autoptr(autoptr<Tp1>a)STLNOTHROW:Mptr(a.release()){}6、7、8是autoptr构造函数的三个版本.6注释：传入对象的指针,构造autoptr.explicit关键字:禁止隐式转换.这就是ok2正确,而no5(隐式转换)错误的原因.7注释：拷贝构造函数.传入autoptr实例,构造autoptr.ok1、ok3使用了这个构造式.它是一个很关键的构造函数,在具体情况下,我们再分析8注释：autoptr的模板成员,可在继承对象重载的基础上,实现特殊功能.举例：classA{public:virtualvoidfook(){cout<<Iamprogramming<<endl;.};classB:publicA{virtualvoidfook(){cout<<Iamworking<<endl;..};autoptr<A>mSMPTRa(newA(33));实质：autoptr<B>mSMPTRb(mSMPTRa);基类的指针可以赋给派生类的指针autoptr<B>mSMPTRb(newB(44));实质：autoptr<A>mSMPTRa(mSMPTRb);派生类的指针不可赋给基类的指针autoptr<A>mSMPTRa(newB(33));ok!mSMPTRa>fook()将调用派生类B的fook()mSMPTRa>A::fook()将调用基类A的fook()autoptr<B>mSMPTRb(newA(33));wrong!9autoptroperator=(autoptra)STLNOTHROW{10if(a!=this){deleteMptr;Mptr=a.release();}11returnthis;12}13template<classTp1>14autoptroperator=(autoptr<Tp1>a)STLNOTHROW{15if(a.get()!=this>get()){deleteMptr;Mptr=a.release();}16returnthis;16}916两个版本的指派函数.deleteMptr;在指派前,销毁原维护的对象.a.release();release操作,详细代码参见2023.用于this获得被指派对象,且将原维护autoptr置空.no3使用了第一种指派.而权限转移正是a.release()的结果.17autoptr()STLNOTHROW{deleteMptr;}构析函数.消除对象.注意这里对对象的要求!17Tpoperator()constSTLNOTHROW{returnMptr;}18Tpoperator>()constSTLNOTHROW{returnMptr;}19Tpget()constSTLNOTHROW{returnMptr;}操作符重载.17注释：提领操作(dereference),获得对象.见ok5用法.18注释：成员运算符重载,返对象指针.19注释：普通成员函数.作用同于重载>运算符20Tprelease()STLNOTHROW{21Tptmp=Mptr;22Mptr=0;23returntmp;}上面已经详解24voidreset(Tpp=0)STLNOTHROW{25deleteMptr;26Mptr=p;}传入对象指针,改变autoptr维护的对象且迫使autoptr消除原来维护的对象见ok3用法.AccordingtotheC++standard,theseconversionsarerequired.Mostpresentdaycompilers,however,donotenforcethatrequirementand,infact,mostpresentdaycompilersdonotsupportthelanguagefeaturesthattheseconversionsrelyon.下面这片段用于类型转化,目前没有任何编译器支持具体技术细节不诉.ifdefSGISTLUSEAUTOPTRCONVERSIONS27private:28template<classTp1>29structautoptrref{Tp1Mptr;autoptrref(Tp1p):Mptr(p){}};30public:31autoptr(autoptrref<Tp>ref)STLNOTHROW:Mptr(ref.Mptr){}32template<classTp1>33operatorautoptrref<Tp1>()STLNOTHROW34{returnautoptrref<Tp>(this>release());}35template<classTp1>operatorautoptr<Tp1>()STLNOTHROW36{returnautoptr<Tp1>(this>release());}37endifSGISTLUSEAUTOPTRCONVERSIONS38};OK!就是这样了.正如上面原理介绍处叙说,你需要正视两大特性：1.构造栈对象的生命期控制堆上构造的对象的生命期2.通过release来保证autoptr对对象的独权.在我们对源码分析的基础上,重点看看：no系列错误在何处?no1.我们看到构析函数template<classTp>autoptr()STLNOTHROW{deleteMptr;}所以它不能维护数组,维护数组需要操作：delete[]Mptr;no2.先提部分vector和autoptr代码：a.提autoptr代码autoptr(autoptra)STLNOTHROW:Mptr(a.release()){}b.提vector代码Part1:voidpushback(constTpx){if(Mfinish!=Mendofstorage){construct(Mfinish,x);++Mfinish;}elseMinsertaux(end(),x);}Part2:template<classT1,classT2>inlinevoidconstruct(T1p,++++++++++++++++++++++++++++++++constT2value){+++++++++++++++++++++++++++++++++new(p)T1(value);+++++++++++++++++++++++++++++++++}Part3.template<classTp,classAlloc>voidvector<Tp,All