??xml version="1.0" encoding="utf-8" standalone="yes"?>
一、定?
U虚函数是在基类中声明的虚函敎ͼ?font color="#ff0000">在基cM没有定义Q但要求Mzc都要定义自q实现Ҏ。在基类中实现纯虚函数的Ҏ是在函数原型后加?0?/p>
virtual void funtion1()=0
二、引入原因:
1、ؓ了方便用多态特性,我们常常需要在基类中定义虚拟函数?br />2、在很多情况下,基类本n生成对象是不合情理的。例如,动物作ؓ一个基cd以派生出老虎、孔雀{子c,但动物本w生成对象明显不合常理?/p>
Z解决上述问题Q引入了U虚函数的概念,函数定义ؓU虚函数Q方法:virtual ReturnType Function()= 0;Q,则编译器要求在派生类中必M以重载以实现多态?/font>。同时含有纯虚拟函数的类UCؓ抽象c,它不能生成对象。这样就很好地解决了上述两个问题?/p>
三、相似概念: 1、多态?/p>
指相同对象收C同消息或不同对象收到相同消息时生不同的实现动作。C++支持两种多态性:~译时多态性,q行时多态性?/p>
a.~译时多态性:通过重蝲函数实现 b q行时多态性:通过虚函?/font>实现?/font> 2、虚函数 虚函数是在基cM被声明ؓvirtualQƈ在派生类中重新定义的成员函数Q可实现成员函数的动态重?/p>
3、抽象类
包含U?/font>虚函数的cȝ为抽象类。由于抽象类包含了没有定义的U虚函数Q所以不能定义抽象类的对象?/p>
E序举例Q?/p>
基类: }; 子类: }; f1()是一个普通的重蝲.
Q四Q?br /> int temp=0; //通过?Ҏ一 的ȝQ我们作如下调整Q在swap()函数中,我们立刻改变临时指针
首先看一下sizeof在msdn上的定义Q?/font>
The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type (including aggregate types). This keyword returns a value of type size_t.
看到returnq个字眼Q是不是惛_了函敎ͼ错了Qsizeof不是一个函敎ͼ你见q给一个函C参数Q而不加括L吗?sizeof可以Q所以sizeof不是函数。网上有sizeof是一元操作符Q但是我q不q么认ؓQ因为sizeof更像一个特D的宏,它是在编译阶D|值的。D个例子:
在编译阶D已l被译为:
cout<<4<<endl;
q里有个陷阱Q看下面的程序:
int a = 0;
输出Z么是4Q?而不是期望中?Q?Q?Q就在于sizeof在编译阶D处理的Ҏ。由于sizeof不能被编译成机器码,所以sizeof作用范围内,也就?)里面的内容也不能被编译,而是被替换成cd?操作W返回左操作数的cdQ所以a=3相当于intQ而代码也被替换ؓQ?/font>
int a = 0;
所以,sizeof是不可能支持铑ּ表达式的Q这也是和一元操作符不一L地方?/font>
l论Q不要把sizeof当成函数Q也不要看作一元操作符Q把他当成一个特D的~译预处理?/font>
2、sizeof的用?/font>
sizeof有两U用法:
Q?Qsizeof(typename)
可以看出Q加()是永q正的选择?/font>
l论Q不论sizeof要对谁取|最好都加上()?/font>
Q?QC++固有数据cd
32位C++中的基本数据cdQ也char,short int(short),int,long int(long),float,double, long double
考虑下面的代码:
cout<<sizeof(unsigned int) == sizeof(int)<<endl; // 相等Q输?1
unsigned影响的只是最高位bit的意义,数据长度不会被改变的?/font>
l论Qunsigned不能影响sizeof的取倹{?/font>
Q?Q自定义数据cd
typedef可以用来定义C++自定义类型。考虑下面的问题:
typedef short WORD;
l论Q自定义cd的sizeof取值等同于它的cd原Ş?/font>
Q?Q函数类?/font>
考虑下面的问题:
int f1(){return 0;};
cout<<sizeof(f1())<<endl; // f1()q回gؓintQ因此被认ؓ是int
l论Q对函数使用sizeofQ在~译阶段会被函数q回值的cd取代Q?/font>
4、指针问?/font>
考虑下面问题Q?br />
可以看到Q不是什么类型的指针Q大都?的,因ؓ指针是32位的物理地址?/font>
l论Q只要是指针Q大就?。(64位机上要变成8也不一定)?/font>
Z唧唧歪歪几句QC++中的指针表示实际内存的地址。和C不一L是,C++中取消了模式之分Q也是不再有small,middle,big,取而代之的是统一的flat。flat模式采用32位实地址dQ而不再是c中的 segment:offset模式。D个例子,假如有一个指向地址 f000:8888的指针,如果是Ccd则是8888(16? 只存储位U,省略D?Qfarcd的C指针是f0008888(32位,高位保留D地址Q地位保留位U?,C++cd的指针是f8888(32位,相当于段地址*16 + 位移Q但d范围要更??/font>
5、数l问?/font>
考虑下面问题Q?/font>
char a[] = "abcdef";
cout<<sizeof(a)<<endl; // 7
数组a的大在定义时未指定Q编译时l它分配的空间是按照初始化的值确定的Q也是7。c是多l数l,占用的空间大是各维数的乘积Q也是6。可以看出,数组的大就是他在编译时被分配的I间Q也是各维数的乘积*数组元素的大?/font>
l论Q数l的大小是各l数的乘U?数组元素的大?/font>
q里有一个陷阱:
int *d = new int[10];
cout<<sizeof(d)<<endl; // 4
d是我们常说的动态数l,但是他实质上q是一个指针,所以sizeof(d)的值是4?/font>
再考虑下面的问题:
double* (*a)[3][6];
a是一个很奇怪的定义Q他表示一个指?double*[3][6]cd数组的指针。既然是指针Q所以sizeof(a)是4?/font>
既然a是执行double*[3][6]cd的指针,*apCZ个double*[3][6]的多l数l类型,因此sizeof(*a)=3*6*sizeof(double*)=72。同LQ?*a表示一个double*[6]cd的数l,所以sizeof(**a)=6*sizeof(double*)=24?**apC其中的一个元素,也就是double*了,所以sizeof(***a)=4。至?***aQ就是一个double了,所以sizeof(****a)=sizeof(double)=8?/font>
考虑下面的问题:
int Sum(int i[])
int main()
Sum的本意是用sizeof得到数组的大,然后求和。但是实际上Q传入自函数Sum的,只是一个int cd的指针,所以sizeof(i)=4Q而不?4Q所以会产生错误的结果。解册个问题的Ҏ使是用指针或者引用?/font>
使用指针的情况:
int main()
int Sum(int (&i)[6])
int main()
int Sum(int *i, unsigned int n)
int main()
7、字W串的sizeof和strlen
考虑下面的问题:
char a[] = "abcdef";
cout<<strlen(a)<<endl; // 6Q字W串长度
a[1] = '\0';
考虑下面问题Q(默认寚w方式Q?/font>
union u
union u2
union u3
cout<<sizeof(u)<<endl; // 8
都知道union的大取决于它所有的成员中,占用I间最大的一个成员的大小。所以对于u来说Q大就是最大的doublecd成员a了,所以sizeof(u)=sizeof(double)=8。但是对于u2和u3Q最大的I间都是char[13]cd的数l,Z么u3的大是13Q而u2?6呢?关键在于u2中的成员int b。由于intcd成员的存在,使u2的对齐方式变?Q也是_u2的大必d4的对界上Q所以占用的I间变成?6Q最接近13的对界)?/font>
l论Q复合数据类型,如unionQstructQclass的对齐方式ؓ成员中对齐方式最大的成员的对齐方式?/font>
Z提一下CPU对界问题Q?2的C++采用8位对界来提高q行速度Q所以编译器会尽量把数据攑֜它的对界上以提高内存命中率。对界是可以更改的,使用#pragma pack(x)宏可以改变编译器的对界方式,默认?。C++固有cd的对界取~译器对界方式与自n大小中较的一个。例如,指定~译器按2对界Qintcd的大是4Q则int的对界ؓ2?中较的2。在默认的对界方式下Q因为几乎所有的数据cd都不大于默认的对界方?Q除了long doubleQ,所以所有的固有cd的对界方式可以认为就是类型自w的大小。更改一下上面的E序Q?/font>
#pragma pack(2)
union u3
cout<<sizeof(u2)<<endl; // 14
׃手动更改对界方式?Q所以int的对界也变成?Qu2的对界取成员中最大的对界Q也?了,所以此时sizeof(u2)=14?/font>
l论QC++固有cd的对界取~译器对界方式与自n大小中较的一个?/font>
因ؓ寚w问题使结构体的sizeof变得比较复杂Q看下面的例子:(默认寚w方式?
struct s1
struct s2
cout<<sizeof(s1)<<endl; // 24
同样是两个charcdQ一个intcdQ一个doublecdQ但是因为对界问题,D他们的大不同。计结构体大小可以采用元素摆放法,我D例子说明一下:首先QCPU判断l构体的对界Q根据上一节的l论Qs1和s2的对界都取最大的元素cdQ也是doublecd的对?。然后开始摆放每个元素?br /> 对于s1Q首先把a攑ֈ8的对界,假定?Q此时下一个空闲的地址?Q但是下一个元素d是doublecdQ要攑ֈ8的对界上Q离1最接近的地址?了,所以d被放在了8Q此时下一个空闲地址变成?6Q下一个元素c的对界是4Q?6可以满Q所以c攑֜?6Q此时下一个空闲地址变成?0Q下一个元素d需要对?Q也正好落在对界上,所以d攑֜?0Q结构体在地址21处结束。由于s1的大需要是8的倍数Q所?1-23的空间被保留Qs1的大变成了24?br /> 对于s2Q首先把a攑ֈ8的对界,假定?Q此时下一个空闲地址?Q下一个元素的对界也是1Q所以b摆放?Q下一个空闲地址变成?Q下一个元素c的对界是4Q所以取?最q的地址4摆放cQ下一个空闲地址变成?Q下一个元素d的对界是8Q所以d摆放?Q所有元素摆攑֮毕,l构体在15处结束,占用ȝ间ؓ16Q正好是8的倍数?/font>
q里有个陷阱Q对于结构体中的l构体成员,不要认ؓ它的寚w方式是他的大小Q看下面的例子:
struct s1
struct s2
struct s3
struct s4
cout<<sizeof(s1)<<endl; // 8
s1和s2大小虽然都是8Q但是s1的对齐方式是1Qs2?QdoubleQ,所以在s3和s4中才有这L差异?/font>
所以,在自己定义结构体的时候,如果I间紧张的话Q最好考虑寚w因素来排列结构体里的元素?/font>
10、不要让doubleq扰你的位域
在结构体和类中,可以使用位域来规定某个成员所能占用的I间Q所以用位域能在一定程度上节省l构体占用的I间。不q考虑下面的代码:
struct s1
struct s2
struct s3
struct s4
cout<<sizeof(s1)<<endl; // 24
可以看到Q有double存在会干涉到位域Qsizeof的算法参考上一节)Q所以用位域的的时候,最好把floatcd和doublecd攑֜E序的开始或者最后?/font>
W一ơ写东西Q发现自q表达能力太差了,知道的东西讲不出来,讲出来的东西别h也看不懂Q呵c另外,C99标准的sizeof已经可以工作在运行时了,打算最q找个支持C99的编译器研究一下?/font>
class A
{
public:
A();
void f1();
virtual void f2();
virtual void f3()=0;
virtual ~A();
class B : public A
{
public:
B();
void f1();
void f2();
void f3();
virtual ~B();
d?
int main(int argc, char* argv[])
{
A *m_j=new B();
m_j->f1();
m_j->f2();
m_j->f3();
delete m_j;
return 0;
}
调用m_j->f1();会去调用AcM的f1(),它是在我们写好代码的时候就会定好的.
也就是根据它是由Acd义的,q样p用这个类的函?
f2()是虚函数.
调用m_j->f2();会调用m_j中到底保存的对象?对应的这个函?q是׃new的B
对象.
f3()与f2()一?只是在基cM不需要写函数现实.
]]>
一般用的最多的怕是char * 了,表示的是指向C风格字串的指针。那 char **p 又是什么呢Qp表示的是指向指针的指针。比如:
//创徏p
char **p=new char*[100];
for(int i=0;i<100;i++)
{
p[i]=new char[30]; // p[i]为指向最l字串的指针Q该字串长度?0Q而p 又是指向p[i]的指?br />}
//释放I间
for(int i=0;i<100;i++)
{
delete p[i];
}
delete p;
]]>
《C++E序设计语言》:如果你只C本C++书,q本是你的选择Q作者Bjarne是让你做出q样选择的全部理由,没有比他更了解什么样才是真正的用C++~程了,有h说到q本书语a晦ӆQ或者对与初学者此书不适合Q对此评论我颇不以ؓӞ我看的是中文版,L在我看来语言描叙非常CQ我喜欢q样的技术描叙风根{全书的核心是告诉你如何去用正的观念~写正确的C++的代码。强烈推荐?br />
《C++语言设计与演化》:q本书也是我同时拥有中英两版的两本书之一Q另外一本是《设计模式》)。如果在得到上面的那本书之后你需要第二本Q那么在我看来这是你的选择Q作者同hBjarneQ他在q本书中告诉你C++的v源与发展Q语a原则与本质,各种Ҏ加入的理由和考量Q以及几乎一切关于C++有趣的故事。我阅读q中׃版,都是强烈推荐?br />
《C++标准E序库》:在AMAZON上面关于C++书籍评论最为火暴的一本。全书对于标准程序库的介l可谓深入浅出,而且全书都是从实际运用出发,书中例子单却非常说明问题Q加上一些图表的陈列Q其概念十分清晎ͼ而且从手册和学习两方面看都有其存在h倹{强烈推荐?br />
《EFFECTIVE C++ 中文版》:无须多说Q在MC++书籍推荐目录中都可以扑ֈq本书的w媄Q盛名之下必无虚士。主要强调的是运用C++的各U特性的时候所必须注意的地方,以及一些比较通用的设计手Dc其短小_悍的语a自然非常适合快节奏的C风格Q个人就十分喜欢Meyer的写作方式。强烈推荐?br />
《MORE EFFECTIVE C++ 中文版》:做ؓ上本书的姐妹,一L写作风格Q一L写作目的。只是个为和其姐姐相比,存在差距Q主要是信息量没有《EFFECTIVE C++ 中文版》那么大Q主要说C一些C++的设计惯用手法。推荐?br />
《C++ PRIMER 中文版》:同样是出自大师之手,作者LIPPMANQ作为早期C++~译器的实现者之一Q对与C++的了解以及该如何论序都有自己的独到见解。做为C++的百U全书和《C++E序设计语言》有着一LC。但是前者更的是C++的语法和其语义,而后者则是以如何用C++q行合理设计做ؓ描叙的中心。全书构思十分y妙,书的一开始就直接q入C++的主题,前面五章都用c设计一个数据结构,让读者完全明白了各种用户定义cd所代表的抽象能力,然后直接q入W六章标准库中的容器c,q样的设计让读者十分清楚的建立容器和类q两个C++中十分重要的概念。这L设计针对有一定基的C++读者来说可以说是非常有效果的。但是对于初学者来_q确实不是一本合适的书籍Q因Z上来太多的名词会把刚刚接触C++的h吓着的。推荐?br />
《C++沉思录》:非常有特点的一本书Q全书假设读者已l通晓C++语言Q重点告诉读者C++的概念以及一些C++的设计手D,比如用C++到底Z么会比C或者其他过E语a更好Q(书中l出的答案是Q因为只有对象才有能力保持一定的状态,而算法没有这L能力Q,如何q行抽象数据cd的程序设计,如何理解多态,如何通过代理隐藏l承Q如何进行引用技敎ͼZ效率如何q行~时拯Q以及模板技术是如何发展演进最后构成成STL库的。阅L觉和《C++E序设计语言》一P思想性非常强Q读q样的书很篏Q脑子必M直思考问题,思考作者里面提出的问题和他提出的解x式。这本书最大的特点是非常直接的把C++语言的核心暴露出?----三种抽象模型和极其语a设施本n对这三种抽象模型的支持。而《C++沉思录》给我的更深层思考是什么才是运用C++最合理的方式。推荐?br />
《C++ STL中文版》:很朴实,不花俏,但是价值很高。个为其主要价g现在以下几个斚wQ?Q对于STL的实现关键iterator一般都使用了两U方式描叙,一U比较老式的函数方法,一U是新的 traits技巧,q样读者可以非常清楚的知道技术的演进?Q提供了一个STL LITE版本Q阅读这L代码对自q提高非常大?Q书中提供的试模块对于读者来说也是非常有的一章,对于x展STL的,可以按照上面提供的方法测试自qSTLlg。缺点:装订比较_糙Q与大师之作的地位不相称。推?br />
《C++ PRIMER PLUS 中文版》:一本思想性不是很强,技巧性不是很强的书,但是对于初学者来说非常合适的书。其中许多论序方式都和具体化QM来说Q这本书是我看过的C++书籍里面最合适初学者的。推荐?br />
《深度探索C++对象模型》:q也是一本比较特别的书,告诉你编译器是如何安排处理对象的内存I间的,以及一些OOҎ是如何实现的。不认ؓq是一本C++必须ȝQ算是课后读物应该比较合适吧Q因为有旉了解C++的OO实现q不如花Ҏ间搞清楚OO理论的本质概念:type theory。推荐?br />
《C++设计新思维——泛型编E与设计模式之应用》:可谓C++中的奇书。这L一本书Q很难让人做出正的评h与推荐指敎ͼ其是以我这个实用和人生本就应该享乐Zh生观的h来说~Q)Q因为全书所代表的思想前卫C有点不切实际的地步,模式+泛型—多么高雅的l合。我个h的观ҎQ只有一部分人需要阅L书,他们是所谓的real c++ fansQ暂且不提C++本n是否遇到了困难,其书中所代表的设计思想Q对于C++没有一Ҏ情的E序员(感情是以爱好ؓ基础Q而不是以攒钱为前提)Q我惛_于这L设计技术M有晕的感觉,而一般程序员多半都不会喜Ƣ这L感觉~Q)。推荐?br />
《对象揭U:Java、Eiffel和C++》:从书名就可以看出q本书不仅仅和C++有关pR可以说全书是对C++的一ơ批判吧Q书也v源与作者的一批判C++的文章)。有时候听听另外一U声韛_自己保持清醒的头脑是非常有帮助的Q对待一个hQ对待一本书以及对待一门程序设计语a都是如此。这本书好象不是很火Q大概跟其宣传不是很CQ或者同能同时了解这三门语言q比较关心这些语a深层ơ的优略的读者比较少有关pdQ在我看来这本书包含了许多对象与cd斚w的理论,最为出彩的是作者抓住Bjarne的“在C++中一个类是一个类型”这L“错误”言论狠批的q程。看q本书另外一个好处是能教会大家该如何d理的辩驳自己的对手~Q)。推荐?br />
《大规模C++E序设计》:书在手上很久了,可一直没有仔l看Q这也是评论之前必须说明的。M看来书中涉及的很多东襉K鲜见于其他读本。不AMAZON上的评论是否是这本书比较q时Qv码它介绍的许多对与我来说都是我所不知道不了解的,别h说过时是他的事情。而我Q还是推荐?br />
《STL和泛型编E》:隑־的一本关于泛型编E的理念书籍Q同样也是作为手册和学习两用Q但是其手册不是使用手册Q而是概念手册Q对于设计自qSTLlgQ这本书有非常好的帮助,虽然|上有篇STL的文档,其中?0%内容和这本书雷同Q但此书仍不失可L。推荐?br />
《C++~程思想 W二版》:非常一般的书,是的q就是我对这本很多h奉ؓ名著的评论,至于Z么是q样的评论,或者你不相信我说的是客观话Q在你买了之后看完就知道了。一般?br />
《Essential C++中文版》:L觉这本书定位不是很清楚,因ؓ对于初学者来说其开始就涉及了太多的名词Q初学者看q本书,几乎׃要指望能很好的入门。而对于进阶者来_其内容ƈ无新意,对于C++高手来说Q这L读本,Ҏ没有阅ȝ必要Q也许是LIPPMAN+JJHOU的盛名吧Q但我觉得这ơ算是有虚士了~Q)。一般?br />
《STL源码剖析》:侯SIR的大陆两本著作之一Q但在我心中其质量好象ƈ不如很多的那样好Q就同类作品《C++ STL中文版》相比较内容略现单薄Qƈ且三章之后很多东襉Klh以堆砌的感觉Q而且大部分精彩的材料都出自《STL和泛型编E》一书,lh感觉书中侯SIR自己的东西ƈ不多Q但W二章对于内存管理有很好的论叙表玎ͼq且装订_良Q尤其是那些图更是侯SIR的拿手好戏,但M感觉有点华而不实。一般?br />
后面列出两本不推荐的Q具体原因也׃再分析?br />
《高质量E序设计指南--C++/C语言》,
《C++~码规范?br />
另外两本常见的C++书籍Q?br />
《Exceptional C++中文版》,《More Exceptional C++中文版》我本hq没有阅读过Q但其名C,而且加之曄l此书作者Herb Sutter通邮件的l历Q那U考虑到时差都不到24个小时的回信率以及在信中耐心的对技术讲解的态度Q同样向大家推荐q两本书Q因为在我看来Herb Sutter能力无须考虑加上q样待h的态度Q其作品理所值得大家阅读?br />
是的Q上面就是我大半q来看过的C++的书c,肯定不少嘲笑我的个书呆子了~Q)Q其实我实是一个书呆子Q至于是否需要看q么多书Q我个h意见是不需要,不然我还l出推荐{q什么?选择自己需要的是最好。引用曾l有到的---评书其实是个“如人饮_h自知”的事情。真正的书评在哪里?各自的心里?br />
]]>
Ҏ一Q?br />int *p;
void swap(int *x,int *y)
{
cout<<"swap("<<*x<<","<<*y<<")"<<endl;
p=x;
x=y;
y=p;
cout<<"swap("<<*x<<","<<*y<<")"<<endl;
}
int main()
{
int a=10;
int b=2;
int *x=&a;
int *y=&b;
cout<<*x<<" "<<*y<<endl;
swap(x,y);
cout<<*x<<" "<<*y<<endl;
}
q算l果却是Q?br />10 2
10 2 //swap
2 10 //swap
10 2
从结果上可以看出swap()仍然没有起到效果
接着?amp;来做实验
Ҏ二:
void swap(int &x,int &y)
{
cout<<"swap("<<x<<","<<y<<")"<<endl;
int temp;
temp=x;
x=y;
y=temp;
cout<<"swap("<<x<<","<<y<<")"<<endl;
}
int main()
{
int a=10;
int b=2;
int &x=a;
int &y=b;
cout<<x<<" "<<y<<endl;
swap(x,y);
cout<<x<<" "<<y<<endl;
}
q算l果是:
10 2
10 2 //swap
2 10 //swap
2 10
从结果上可以看出swap()起到预定效果
用int *&做实?br />Ҏ三:
int *p;
void swap(int *&x,int *&y)
{
cout<<"swap("<<*x<<","<<*y<<")"<<endl;
p=x;
x=y;
y=p;
cout<<"swap("<<*x<<","<<*y<<")"<<endl;
}
int main()
{
int a=10;
int b=2;
int *x=&a;
int *y=&b;
cout<<*x<<" "<<*y<<endl;
swap(x,y);
cout<<*x<<" "<<*y<<endl;
}
q算l果是:
10 2
10 2 //swap
2 10 //swap
2 10
从结果上可以看出swap()起到预定效果
最后,再次用int *做实验,注意swap()部分的变?br />Ҏ四:
void swap(int *x,int *y)
{
int temp=0;
cout<<"swap("<<*x<<","<<*y<<")"<<endl;
temp=*x;
*x=*y;
*y=temp;
cout<<"swap("<<*x<<","<<*y<<")"<<endl;
}
int main()
{
int a=10;
int b=2;
int *x=&a;
int *y=&b;
cout<<*x<<" "<<*y<<endl;
swap(x,y);
cout<<*x<<" "<<*y<<endl;
}
q算l果是:
10 2
10 2 //swap
2 10 //swap
2 10
从结果上可以看出swap()起到预定效果
=============================================================
好,现在来说下ؓ什么用方法一和方法四Q同h传递的地址Qؓ什么结果会不同Q答案就在swap(int *x,int *y)上。在main()里虽然有x和y指针Q但是,在swap()里的x,y却是临时变量。首先说明这一Ҏ有好处的。我们来l箋分析以下代码内容Q?br /> Q一Q?br /> p=x; //该方法看似我们希望通过交换临时指针x,y所指向的地址Q来辑ֈ交换main()函数中实参x,y所?br /> x=y; //向地址Q从而达C换数值的效果。虽焉辑上是正确的,E序~译也通过Q但是,却忽略了
y=p; //一个非帔R要的内容Q那是swap()中的x,y仍然是时的Q虽然该E序实在swap中暂时交?br /> //了x,y所指向的地址Q?u>但是实际上x,y所指向地址的数g然没有被改变Q?
temp=*x; //x,y所指向地址的数|x变main()函数中实参指针x,y所指向地址的数倹{所以,即
*x=*y; //swap()函数调用完后内部临时x,y消失Q但它们所做的工作已经完成Q改变数|
*y=temp;
同理Q对于方法三和方法二Q通过int & 和int *&也是做了cMҎ四的工作Q所以能正确swap所需内容?br />至于说用哪U方法,是仁者见仁的事了?br />
]]>
1、什么是sizeof
cout<<sizeof(int)<<endl; // 32位机上int长度?
cout<<sizeof(1==2)<<endl; // == 操作W返回boolcdQ相当于 cout<<sizeof(bool)<<endl;
cout<<1<<endl;
cout<<sizeof(a=3)<<endl;
cout<<a<<endl;
cout<<4<<endl;
cout<<a<<endl;
Q?Qsizeof(object)
也就是对对象使用sizeofQ也可以写成sizeof object 的Ş式。例如:
也就是对cd使用sizeofQ注意这U情况下写成sizeof typename是非法的。下面D几个例子说明一下:
int i = 2;
cout<<sizeof(i)<<endl; // sizeof(object)的用法,合理
cout<<sizeof i<<endl; // sizeof object的用法,合理
cout<<sizeof 2<<endl; // 2被解析成intcd的object, sizeof object的用法,合理
cout<<sizeof(2)<<endl; // 2被解析成intcd的object, sizeof(object)的用法,合理
cout<<sizeof(int)<<endl;// sizeof(typename)的用法,合理
cout<<sizeof int<<endl; // 错误Q对于操作符Q一定要?)
3、数据类型的sizeof
大小分别是:1Q?Q?Q?Q?Q?, 10?/font>
typedef long DWORD;
cout<<(sizeof(short) == sizeof(WORD))<<endl; // 相等Q输?
cout<<(sizeof(long) == sizeof(DWORD))<<endl; // 相等Q输?
double f2(){return 0.0;}
void f3(){}
cout<<sizeof(f2())<<endl; // f2()q回gؓdoubleQ因此被认ؓ是double
cout<<sizeof(f3())<<endl; // 错误Q无法对voidcd使用sizeof
cout<<sizeof(f1)<<endl; // 错误Q无法对函数指针使用sizeof
cout<<sizeof*f2<<endl; // *f2Q和f2(){hQ因为可以看作objectQ所以括号不是必要的。被认ؓ是double
cout<<sizeof(string*)<<endl; // 4
cout<<sizeof(int*)<<endl; // 4
cout<<sizof(char****)<<endl; // 4
int b[20] = {3, 4};
char c[2][3] = {"aa", "bb"};
cout<<sizeof(b)<<endl; // 20*4
cout<<sizeof(c)<<endl; // 6
cout<<sizeof(a)<<endl; // 4
cout<<sizeof(*a)<<endl; // 72
cout<<sizeof(**a)<<endl; // 24
cout<<sizeof(***a)<<endl; // 4
cout<<sizeof(****a)<<endl; // 8
6、向函数传递数l的问题?/font>
#include <iostream>
using namespace std;
{
int sumofi = 0;
for (int j = 0; j < sizeof(i)/sizeof(int); j++) //实际上,sizeof(i) = 4
{
sumofi += i[j];
}
return sumofi;
}
{
int allAges[6] = {21, 22, 22, 19, 34, 12};
cout<<Sum(allAges)<<endl;
system("pause");
return 0;
}
int Sum(int (*i)[6])
{
int sumofi = 0;
for (int j = 0; j < sizeof(*i)/sizeof(int); j++) //sizeof(*i) = 24
{
sumofi += (*i)[j];
}
return sumofi;
}
{
int allAges[] = {21, 22, 22, 19, 34, 12};
cout<<Sum(&allAges)<<endl;
system("pause");
return 0;
}
在这个Sum里,i是一个指向i[6]cd的指针,注意Q这里不能用int Sum(int (*i)[])声明函数Q而是必须指明要传入的数组的大,不然sizeof(*i)无法计算。但是在q种情况下,再通过sizeof来计数l大已l没有意义了Q因为此时大是指定?的?br />使用引用的情况和指针怼Q?/font>
{
int sumofi = 0;
for (int j = 0; j < sizeof(i)/sizeof(int); j++)
{
sumofi += i[j];
}
return sumofi;
}
{
int allAges[] = {21, 22, 22, 19, 34, 12};
cout<<Sum(allAges)<<endl;
system("pause");
return 0;
}
q种情况下sizeof的计同h意义Q所以用数组做参敎ͼ而且需要遍历的时候,函数应该有一个参数来说明数组的大,而数l的大小在数l定义的作用域内通过sizeof求倹{因此上面的函数正确形式应该是:
#include <iostream>
using namespace std;
{
int sumofi = 0;
for (int j = 0; j < n; j++)
{
sumofi += i[j];
}
return sumofi;
}
{
int allAges[] = {21, 22, 22, 19, 34, 12};
cout<<Sum(i, sizeof(allAges)/sizeof(int))<<endl;
system("pause");
return 0;
}
char b[20] = "abcdef";
string s = "abcdef";
cout<<sizeof(a)<<endl; // 7Q字W串定w
cout<<strlen(b)<<endl; // 6Q字W串长度
cout<<strlen(b)<<endl; // 20Q字W串定w
cout<<sizeof(s)<<endl; // 12, q里不代表字W串的长度,而是stringcȝ大小
cout<<strlen(s)<<endl; // 错误Qs不是一个字W指针?/font>
cout<<strlen(a)<<endl; // 1
cout<<sizeof(a)<<endl; // 7Qsizeof是恒定的
strlen是寻找从指定地址开始,到出现的W一?之间的字W个敎ͼ他是在运行阶D|行的Q而sizeof是得到数据的大小Q在q里是得到字W串的容量。所以对同一个对象而言Qsizeof的值是恒定的。string是C++cd的字W串Q他是一个类Q所以sizeof(s)表示的ƈ不是字符串的长度Q而是cstring的大。strlen(s)Ҏ是错误的,因ؓstrlen的参数是一个字W指针,如果想用strlen得到s字符串的长度Q应该用sizeof(s.c_str())Q因为string的成员函数c_str()q回的是字符串的首地址。实际上QstringcL供了自己的成员函数来得到字符串的定w和长度,分别是Capacity()和Length()。string装了常用了字符串操作,所以在C++开发过E中Q最好用string代替Ccd的字W串?/font>
8、从union的sizeof问题看cpu的对?/font>
{
double a;
int b;
};
{
char a[13];
int b;
};
{
char a[13];
char b;
};
cout<<sizeof(u2)<<endl; // 16
cout<<sizeof(u3)<<endl; // 13
union u2
{
char a[13];
int b;
};
{
char a[13];
char b;
};
#pragma pack(8)
cout<<sizeof(u3)<<endl; // 13
9、struct的sizeof问题
{
char a;
double b;
int c;
char d;
};
{
char a;
char b;
int c;
double d;
};
cout<<sizeof(s2)<<endl; // 16
{
char a[8];
};
{
double d;
};
{
s1 s;
char a;
};
{
s2 s;
char a;
};
cout<<sizeof(s2)<<endl; // 8
cout<<sizeof(s3)<<endl; // 9
cout<<sizeof(s4)<<endl; // 16;
{
int i: 8;
int j: 4;
double b;
int a:3;
};
{
int i;
int j;
double b;
int a;
};
{
int i;
int j;
int a;
double b;
};
{
int i: 8;
int j: 4;
int a:3;
double b;
};
cout<<sizeof(s2)<<endl; // 24
cout<<sizeof(s3)<<endl; // 24
cout<<sizeof(s4)<<endl; // 16
]]>
void key(char *p)
{
p="ac";
}
int main()
{
char *p="d";
cout<<p<<endl;
key(p);
cout<<p<<endl;
delete p;
}
//该程序只输出 "d"
/***********************/
/*******正确E序*******/
void key(char *p)
{
strcpy(p,"ac");
}
int main()
{
char *p=new char[5];
strcpy(p,"e");
cout<<p<<endl;
key(p);
cout<<p<<endl;
delete[] p;
}
先输?"e",再输?ac"
/**********************/
==================================
W一个程序:
char *p="d";//p指向帔R字符?br /> cout<<p<<endl;
key(char *p) //试图改变pQ语法无误,但逻辑不允许,故编译正,q行错误。在E序~译的时候; void key(char *p)cM被解释成Qvoid key(const char *p){p="ac";}
W二个程序:
char *p = new char[100];//p指向数组的首地址Q内容可?br /> strcpy(p, "d");//内容变ؓ“d?br /> cout<<p<<endl;
key(p);//内容变ؓ“ac”,strcpyQ)不改变它的地址Q只改变p所指的数组的内容,故输Zؓac
C风格字串不支持直接赋|要用strcpy()?br />
|
using namespace std;
class String;
istream& operator>>(istream&, String&);
ostream& operator<<(ostream&,const String&);
class String
{
public:
//构造函?br /> //String s1();
//String s1("abc");
//String s2(s1);
String();
String(const char*);
String(const String&);
//析构函数
~String();
//赋值操?br /> String& operator=(const char*);
String& operator=(const String&);
//{于操作
bool operator==(const char*);
bool operator==(const String&);
//加操?br /> String operator+(const String&) const;
//下标操作
char& operator[](int);
//成员操作
int size(){return _size;}
char* c_str(){return _string;}
//记数操作
int count(const char) const;
private:
int _size;
char *_string;
};
inline String::String() //构造函?br />{
_size=0;
_string=0;
}
inline String::String(const char* str) //构造函?br />{
if(!str)
{
_size=0;
_string=0;
}
else
{
_size=strlen(str);
_string=new char[_size+1];
strcpy(_string,str);
}
}
inline String::String(const String& str) //拯构造函?br />{
if(!str._size)
{
_size=0;
_string=0;
}
else
{
_size=strlen(str._string);
_string=new char[_size+1];
strcpy(_string,str._string);
}
}
inline String::~String() //析构函数
{
delete[] _string;
}
inline String& String::operator=(const char* str) //赋值操?br />{
if(!str)
{
_size=0;
delete[] _string;
_string=0;
}
else
{
_size=strlen(str);
delete[] _string;
_string=new char[_size+1];
strcpy(_string,str);
}
return *this;
}
inline String& String::operator=(const String &str) //赋值操?br />{
if(this!=&str)
{
_size=str._size;
delete[] _string;
_string=new char[_size+1];
strcpy(_string,str._string);
}
return *this;
}
inline bool String::operator==(const String &rhs) //{于操作W重?br />{
if(_size!=rhs._size)
return false;
return strcmp(_string,rhs._string)?false:true;
}
inline bool String::operator==(const char *str) //{于操作W重?br />{
return strcmp(_string,str)?false:true;
}
inline char& String::operator[](int n) //下标讉KW?br />{
assert(n>=0 && n<_size);
return _string[n];
}
inline int String::count(const char s) const //记数操作
{
int tempCount=0;
for(int i=0;i<_size;i++)
{
if(_string[i]==s)
++tempCount;
}
return tempCount;
}
inline String String::operator+(const String& str) const //加操?br />{
String tempStr;
tempStr._size=_size+str._size;
tempStr._string=new char[tempStr._size+1];
strcpy(tempStr._string,_string);
strcat(tempStr._string,str._string);
return tempStr;
}
inline istream& operator>>(istream &io,String &str) //输入?br />{
const int limit_string_size =4096;
char inBuf[limit_string_size];
io>>setw(limit_string_size)>>inBuf;
str=inBuf;
return io;
}
inline ostream& operator<<(ostream &os,String &str) //输出?br />{
return os<<str.c_str();
}
int main()
{
String str1="abc";
String str2="def";
str1.size();
cout<<"size :"<<str1.size()<<endl;
cout<<"b count :"<<str1.count('b')<<endl;
String str3=str1+str2;
cout<<str3; //该处不能为String&Q只能ؓString。见String operator+()和ostream& operator<<(ostream &os,String &str)
return 0;
}
SO GOOD!
1. fopen()函数
fopen函数用于打开文g, 其调用格式ؓ:
FILE *fopen(char *filename, *type);
在介l这个函C;? 先了解一下下面的知识?
(1) ?stream)和文?file)
和文g 在Turbo C2.0中是有区别的, Turbo C2.0 为编E者和被访问的?
备之间提供了一层抽象的东西, UC??, 而将具体的实际设备叫做文件?
是一个逻辑讑֤, h相同的行为。因? 用来q行盘文g写的函数也同?
可以用来q行打印机的写入。在Turbo C2.0中有两种性质的流: 文字? text
stream)和二q制(binary stream)。对盘来说是文本文g和二q制文g。本
软gZ便于让读者易理解Turbo C2.0语言而没有对和文g作特别区分?
(2) 文g指针FILE
实际上FILE是一个新的数据类型。它是Turbo C2.0的基本数据类型的集合,
UC为结构指针。有关结构的概念在W四节中详细介绍, q里只要FILE理解
Z个包括了文g理有关信息的数据结? 卛_打开文g时必d定义一个文
件指针?
(3) 以后介绍的函数调用格式将直接写出形式参数的数据类型和函数q回?
的数据类型。例? 上面打开文g的函? q回一个文件指? 其中形式参数?
两个, 均ؓ字符型变?字符串数l或字符串指?。本软g不再对函数的调用?
式作详细说明?
现在再来看打开文g函数的用法?
fopen()函数中第一个Ş式参数表C文件名, 可以包含路径和文件名两部分?
?
"B:TEST.DAT"
"C:\\TC\\TEST.DAT"
如果\径写?C:\TC\TEST.DAT"是不正确? q一点要特别注意?
W二个Ş式参数表C打开文g的类型。关于文件类型的规定参见下表?
表?文g操作cd
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
字符 含义
────────────────────────────
"r" 打开文字文g只读
"w" 创徏文字文g只写
"a" 增补, 如果文g不存在则创徏一?
"r+" 打开一个文字文件读/?
"w+" 创徏一个文字文件读/?
"a+" 打开或创Z个文件增?
"b" 二进制文?可以和上面每一合?
"t" 文这文g(默认?
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
如果要打开一个CCDOS子目录中, 文g名ؓCLIB的二q制文g, 可写?
fopen("c:\\ccdos\\clib", "rb");
如果成功的打开一个文? fopen()函数q回文g指针, 否则q回I指?
(NULL)。由此可判断文g打开是否成功?
2. fclose()函数
fclose()函数用来关闭一个由fopen()函数打开的文?, 其调用格式ؓ:
int fclose(FILE *stream);
该函数返回一个整型数。当文g关闭成功? q回0, 否则q回一个非零倹{?
可以Ҏ函数的返回值判断文件是否关闭成功?
?0:
#iclude<stdio.h>
main()
{
FILE *fp; /*定义一个文件指?/
int i;
fp=fopen("CLIB", "rb"); /*打开当前目录名ؓCLIB的文件只?/
if(fp==NULL) /*判断文g是否打开成功*/
puts("File open error");/*提示打开不成?/
i=fclose(fp); /*关闭打开的文?/
if(i==0) /*判断文g是否关闭成功*/
printf("O,K"); /*提示关闭成功*/
else
puts("File close error");/*提示关闭不成?/
}
二、有x件操作的函数
本节所讲的文gd函数均是指顺序读? 卌写了一条信息后, 指针自动
?。下面分别介l写操作函数和读操作函数?
1. 文g的顺序写函数
fprintf()、fputs()和fputc()函数
函数fprintf()、fputs()和fputc()均ؓ文g的顺序写操作函数, 其调用格
式如?
int fprintf(FILE *stream, char *format, <variable-list>);
int fputs(char *string, FILE *steam);
int fputc(int ch, FILE *steam);
上述三个函数的返回值均为整型量。fprintf() 函数的返回gؓ实际写入?
件中的字|个?字节?。如果写错误, 则返回一个负? fputs()函数q回0?
表明string指针所指的字符串写入文件中的操作成? q回?? 表明写操
作失败。fputc()函数q回一个向文g所写字W的? 此时写操作成? 否则q?
回EOF(文gl束l束其gؓ-1, 在stdio.h中定?表示写操作错误?
fprintf( ) 函数中格式化的规定与printf( ) 函数相同, 所不同的只?
fprintf()函数是向文g中写入。而printf()是向屏幕输出?
下面介绍一个例? q行后后一个test.dat的文件?
?1:
#include<stdio.h>
main()
{
char *s="That's good news"); /*定义字符串指针ƈ初始?/
int i=617; /*定义整型变量q初始化*/
FILE *fp; /*定义文g指针*/
fp=fopne("test.dat", "w"); /*建立一个文字文件只?/
fputs("Your score of TOEFLis", fp);/*向所建文件写入一串字W?/
fputc(':', fp); /*向所建文件写冒号:*/
fprintf(fp, "%d\n", i); /*向所建文件写一整型?/
fprintf(fp, "%s", s); /*向所建文件写一字符?/
fclose(fp); /*关闭文g*/
}
用DOS的TYPE命o昄TEST.DAT的内容如下所C?
屏幕昄
Your score of TOEFL is: 617
That's good news
2. 文g的顺序读操作函数
fscanf()、fgets()和fgetc()函数
函数fscanf()、fgets()和fgetc()均ؓ文g的顺序读操作函数, 其调用格?
如下:
int fscanf(FILE *stream, char *format, <address-list>);
char fgets(char *string, int n, FILE *steam);
int fgetc(FILE *steam);
fscanf()函数的用法与scanf()函数怼, 只是它是从文件中d信息?
fscanf()函数的返回gؓEOF(?1), 表明读错? 否则L据成功。fgets()?
C文g中读取至多n-1个字W?n用来指定字符?, q把它们攑օstring指向?
字符串中, 在读入之后自动向字符串未֊一个空字符, L功返回string指针,
p|q回一个空指针。fgetc()函数q回文g当前位置的一个字W? 读错误时q?
回EOF?
下面E序d?1产生的test.dat文g, q将d的结果显C在屏幕上?
?2
#include<stdio.h>
main()
{
char *s, m[20];
int i;
FILE *fp;
fp=fopen("test.dat", "r"); /*打开文字文g只读*/
fgets(s, 24, fp); /*从文件中d23个字W?/
printf("%s", s); /*输出所ȝ字符?/
fscanf(fp, "%d", &i); /*d整型?/
printf("%d", i); /*输出所L型数*/
putchar(fgetc(fp)); /*d一个字W同时输?/
fgets(m, 17, fp); /*d16个字W?/
puts(m); /*输出所dW串*/
fclose(fp); /*关闭文g*/
getch(); /*{待M?/
}
q行后屏q显C?
Your score of TOEFL is: 617
That's good news
如果上例中fscanf(fp, "%d", &i)改ؓfscanf(fp, "%s", m), 再将其后
的输句改为printf("%s", m), 则可得出同样的结果。由此可见Turbo C2. 0
中只要是L字文? 则不论是字符q是数字都将按其ASCII值处理?另外q要
说明的一点就是fscanf()函数dI白W时, 便自动结? 在用时要特别注意?
3. 文g的随?
有时用户想直接读取文件中间某处的信息, 若用文g的顺序读写必M文g
头开始直到要求的文g位置再读, q显然不方便。Turbo C2.0提供了一l文件的
随机d函数, 卛_以将文g位置指针定位在所要求d的地方直接读写?
文g的随写函数如?
int fseek (FILE *stream, long offset, int fromwhere);
int fread(void *buf, int size, int count, FILE *stream);
int fwrite(void *buf, int size, int count, FILE *stream);
long ftell(FILE *stream);
fseek()函数的作用是文件的位置指针讄Cfromwhere开始的Woffset
字节的位|上, 其中fromwhere是下列几个宏定义之一:
文g位置指针起始计算位置fromwhere
━━━━━━━━━━━━━━━━━━━━━━━━━━?
W号常数 数值 ?含义
───────────────────────────
SEEK_SET 0 从文件开?
SEEK_CUR 1 从文件指针的现行位置
SEEK_END 2 从文件末?
━━━━━━━━━━━━━━━━━━━━━━━━━━?
offset是指文g位置指针从指定开始位|?fromwhere指出的位|?跌的字
节数。它是一个长整型? 以支持大?4K字节的文件。fseek()函数一般用于对
二进制文件进行操作?
当fseek()函数q回0时表明操作成? q回?表示p|?
下面E序从二q制文gtest_b.dat中读取第8个字节?
?3:
#include<stdio.h>
main()
{
FILE *fp;
if((fp=fopen("test_b.dat", "rb"))==NULL)
{
printf("Can't open file");
exit(1);
}
fseek(fp, 8. 1, SEEK_SET);
fgetc(fp);
fclose(fp);
}
fread()函数是从文g中读count个字D? 每个字段长度为size个字? q把
它们存放到buf指针所指的~冲器中?
fwrite()函数是把buf指针所指的~冲器中, 长度为size个字节的count个字
D写到stream指向的文件中厅R?
随着d写字节数的增? 文g位置指示器也增大, d个字节, 文g?
|指C器相应也蟩q多个字节。读写完毕函数返回所d所写的字段个数?
ftell()函数q回文g位置指示器的当前? q个值是指示器从文g头开?
v的字节数, q回的数为长整型? 当返?1? 表明出现错误?
下面E序把一个QҎl以二进制方式写入文件test_b.dat中?
?4:
#include <stdio.h>
main()
{
float f[6]={3.2, -4.34, 25.04, 0.1, 50.56, 80.5};
/*定义点数组q初始化*/
int i;
FILE *fp;
fp=fopen("test_b.dat", "wb"); /*创徏一个二q制文g只写*/
fwrite(f, sizeof(float), 6, fp);/*?个QҎ写入文g?/
fclose(fp); /*关闭文g*/
}
下面例子从test_b.dat文g中读100个整型数, q把它们攑ֈdat数组中?
?5:
#include <stdio.h>
main()
{
FILE *fp;
int dat[100];
fp=fopen("test_b.dat", "rb");/*打开一个二q制文g只读*/
if(fread(dat, sizeof(int), 100, fp)!=100)
/*判断是否M100个数*/
{
if(feof(fp))
printf("End of file"); /*不到100个数文gl束*/
else
printf("Read error"); /*L错误*/
fclose(fp); /*关闭文g*/
}
注意:
当用标准文g函数Ҏ件进行读写操作时, 首先所d的内Ҏq缓冲区,
卛_函数只对输出~冲行操? d数只对输入缓冲区q行操作。例如向一
个文件写入内? 所写的内容首先放在输出缓冲区? 直到输出~冲区存满或
使用fclose()函数关闭文g? ~冲区的内容才会写入文g中。若无fclose()
函数, 则不会向文g中存入所写的内容或写入的文g内容不全。有一个对~冲?
q行h的函? 即fflush(), 其调用格式ؓ:
int fflush(FILE *stream);
该函数将输出~冲区的内容实际写入文g? 而将输入~冲区的内容清除掉?
4. feof()和rewind()函数
q两个函数的调用格式?
int feof(FILE *stream);
int rewind(FILE *stream);
feof()函数文件位|指C器是否到达了文件结? 若是则返回一个非0
? 否则q回0。这个函数对二进制文件操作特别有? 因ؓ二进制文件中, ?
件结标志EOF也是一个合法的二进制数, 只简单的查读入字W的值来判断?
件是否结束是不行的。如果那L? 可能会造成文g未结而被认ؓl尾, 所
以就必须有feof()函数?
下面的这条语句是常用的判断文件是否结束的Ҏ?
while(!feof(fp))
fgetc(fp);
while为@环语? 在下面介绍?
rewind()函数用于把文件位|指C器Ud文g的v点处, 成功时返?, ?
? q回?倹{?
1.2.2 非标准文件函?
q类函数最早用于UNIX操作pȝ, ANSI标准未定? 但有时也l常用到,
DOS 3.0以上版本支持q些函数。它们的头文件ؓio.h?
一、文件的打开和关?
1. open()函数
open()函数的作用是打开文g, 其调用格式ؓ:
int open(char *filename, int access);
该函数表C按access的要求打开名ؓfilename的文? q回gؓ文g描述?
其中access有两部分内容: 基本模式和修饰符, 两者用" "("?)方式q接。修
饰符可以有多? 但基本模式只能有一个。access的规定如?-2?
?access的规?
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
基本模式 含义 修饰W ?含??
────────────────────────────
O_RDONLY 只读 O_APPEND 文g指针指向末尾
O_WRONLY 只写 O_CREAT 文g不存在时创徏文g,
属性按基本模式属?
O_RDWR d O_TRUNC 若文件存? 其长度
~ؓ0, 属性不?
O_BINARY 打开一个二q制文g
O_TEXT 打开一个文字文?
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
open()函数打开成功, q回值就是文件描q字的?非负?, 否则q回-1?
2. close()函数
close()函数的作用是关闭由open()函数打开的文? 其调用格式ؓ:
int close(int handle);
该函数关闭文件描q字handle相连的文件?
二、读写函?
1. read()函数
read()函数的调用格式ؓ:
int read(int handle, void *buf, int count);
read()函数从handle(文g描述?相连的文件中, dcount个字节放到buf
所指的~冲Z, q回gؓ实际所d节数, q回-1表示出错。返? 表示文g
l束?
2. write()函数
write()函数的调用格式ؓ:
int write(int handle, void *buf, int count);
write()函数把count个字节从buf指向的缓冲区写入与handle相连的文件中,
q回gؓ实际写入的字节数?
三、随机定位函?
1. lseek()函数
lseek()函数的调用格式ؓ:
int lseek(int handle, long offset, int fromwhere);
该函数对与handle相连的文件位|指针进行定? 功能和用法与fseek() ?
数相同?
2. tell()函数
tell()函数的调用格式ؓ:
long tell(int handle);
该函数返回与handle相连的文件现生位|指? 功能和用法与ftell()相同?
?/span>
:char a[100];memset(a, '\0', sizeof(a));
memset
可以方便的清IZ个结构类型的变量或数l?/span>
如:
struct sample_struct
{
char csName[16];
int iSeq;
int iType;
};
对于变量
struct sample_strcut stTest;
一般情况下Q清I?/span>
stTest
的方法:
stTest.csName[0]='\0';
stTest.iSeq=0;
stTest.iType=0;
?/span>
memset
非常方便:
memset(&stTest,0,sizeof(struct sample_struct));
如果是数l:
struct sample_struct TEST[10];
?/span>
memset(TEST,0,sizeof(struct sample_struct)*10);
memcpy
用来做内存拷贝,你可以拿它拷贝Q何数据类型的对象Q可以指定拷贝的数据长度?/span>
例:
char a[100],b[50]; memcpy(b, a, sizeof(b));
注意如用
sizeof(a)
Q会造成
b
的内存地址溢出?/span>
Strcpy
只能拷贝字W串了,它遇?/span>
'\0'
q束拷贝?/span>
例:
char a[100],b[50];strcpy(a,b);
如用
strcpy(b,a)
Q要注意
a
中的字符串长度(W一?/span>
‘\
str
也可以用用个参数?/span>
strncpy(a,b,n)
========================================================
memset
主要应用是初始化某个内存I间?/span>
memcpy
是用?/span>
copy
源空间的数据到目的空间中?/span>
strcpy
用于字符?/span>
copy,
遇到
‘\
如果你理解了q些Q你应该知道他们的区别:例如你初始化某块I间的时候,用到
memcpy
Q那么应该怎么写,是不是显得很W?/span>
int m[100]
->memset((void*)m,0x00,sizeof(int)*100);//Ok
Q?/span>
…memcpy((void*)m,"\0\0\0\0....",sizeof(int)*100);//it’s wrong.
name1是数l指?name1[0]是数组中的g.
你可以直接用name1->来调?
name1是指针,它和name2q没有什么不?同样你也可以用name2[0].来调用函?
Name[0]指的是数l中的第一个元素,不是个指针~~~~~~~
在定义Name *name1=new Name[4]时name1实是个指针Q他指向了数lName[] 而用name1->show()应该是正的Q这L话就相当于将函数show的首地址l了name1Q?Name *name2=new Name();表示开辟了一个函数Name的内存地址Qname2表示了这个函数的首地址
我一直以为由于都是由new 构成的,所以,W一个name 和第二个name都是指针?br />Q-Q-Q-Q-Q-Q-Q-Q-Q-Q-
正是如此Q?br />都是指针Q但?name1[0]是g ... 同样Qname2[0]也是一个|g自己试试q道了 ..
Name *name2=new Name();
//首先构造Name()默认构造函数对象然后new出对象拷贝构造出?br />Name *name2=new Name[3]Q?br />//是先分配I间然后构造对?
Name1[0]是个对象Q如果你拯了其他对象给他,当然你是要拷l他才能用)
Name1,Name2都是指针
?br />int* p1 = new int[4];
int* p2 = new int;
一?
指针是这L滴~~~
for(int i = 0;i < 4; i++) {
(name1+i)->show();
}
name2 是构造单个对象指?br />name1是构造四个对象的指针。具体到每一个对象就不是指针Q而是数组
//#include
class A
{
public:
int a;
int& get(){return a;};
void set(int i){ a=i;};
A()
{
a=1;
};
};
int main()
{
//
A* a1=new A();
A* a2=new A();
A* pA[2]={a1,a2};
int b=pA[0]->get();
//
int pI[2]={1,2};
int sum=pI[1]+pI[2];
//
A* pB=new A[2];
pB[1].set(1);
int x=pB[1].a;
return 0;
}
是指?但是是数l的指针
比如q样
name *p = new name[4];
p->show()相当于p[0].show();
通俗的说,你在定义的时候的那个name*中的*h的是对象数组,q不是对象指?
name1[0]->show();里的name1[0]Ҏname1OK了。楼d以补一补数l的有关知识?br />
========================================================
copy了这文章,其实我只惌下我的看法?br />Name *p=new Name[4];
p->show(); //正确
p[0].show(); //正确
W一个可以这L解:指针P指向数组首地址Q其实就是P指向Name[4]数组中第一个元素的地址Q所以,如果使用p->show(),则意思其实就是让数组中第一个元素,即第一个对象name调用自nshow(),再说白点Q就是name.show()Q?br />W?个可以这L解:p[0]可以理解成P指向数组中第[0]个元素,所以就有了p[0]Q所以更会有了p[0].show();