来源：蜘蛛抓取(WebSpider)
时间：2014-10-06 09:05
标签：
孙友元
历年计算机二级c++真题及答案_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
13页免费15页免费110页免费110页7下载券195页7下载券80页免费22页7下载券34页4下载券93页7下载券
历年计算机二级c++真题及答案|
把文档贴到Blog、BBS或个人站等：
普通尺寸(450*500pix)
较大尺寸(630*500pix)
你可能喜欢C++ Part II_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
文档贡献者贡献于
评价文档：
29页免费32页免费19页免费37页免费24页免费24页免费8页免费19页免费48页免费22页免费
C++ Part II|
把文档贴到Blog、BBS或个人站等：
普通尺寸(450*500pix)
较大尺寸(630*500pix)
大小：1.48MB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢加载中，请稍候...
加载中，请稍候...
京 东 价：
￥72.90 [7.5折][定价：￥98.00]
温馨提示：
其它类似商品
正在加载中，请稍候...
正在加载中，请稍候...
正在加载中，请稍候...
从新手到高手C＋＋全方位学习（附赠DVD光盘1张）
查找同类商品
完整版《零起点学通C++》大型多媒体教学课堂，30小时1000多节专家讲解。 针对重要的概念精心设计了438个实用范例，囊括大量经验和技巧，重点难点全面透析。 部分视频已在网上发布，在C++开发音中广为流传，深受读者欢迎。 高清语音视频讲解，重点难点全面透析。 DVD大型多媒体教学课堂 《从新手到高手C++全方位学习》配套视频《零起点学通C++》预先在学吧学吧（）和网易学院（）发布后，深受读者欢迎，很快就在各大网站流传开，在Google上搜索有98200条查询结果！ 作者综合了200多个读者的反馈意见后，整理出30小时1000多节精品视频教程，并包含438个实例源程序，让读者全方位、深入地学习C++知识。 C++其实并不难学，只是许多书由于组织框架和表达方式等原因无意中增加了学习难度。 范磊老师写的这《从新手到高手C++全方位学习》不按照传统模式，而是从一个最简短的C++程序讲起，通过对这个程序的编写引申出一系列相关知识，然后不断地扩大和完善该程序，让读者循序渐进地进行学习，同时也能深刻理解C++的各个语法要领。 建议初学者认真阅读此书，尽可能少走弯路，给自己的编程生涯打下坚实的基础。
《从新手到高手C++全方位学习》总结了十几本C++图书及教材的优点，摈弃了它们语言拖沓、层次结构混乱等缺陷，从零开始、由浅入深、层层递进、细致而又详尽地讲解C++这门大型编程语言。《从新手到高手C++全方位学习》知识系统全面，拥有字典般的容量，可随用随查，涵盖指针、面向对象、操作符重载、流、命名空问、模板、异常处理、宏等主流C++开发技术。为了使读者能够活学活用，《从新手到高手C++全方位学习》针对重要的概念精心设计了438个实用范例，囊括大量经验和技巧，即使已从事C++工作多年的朋友，也能从中汲取新的养料。《从新手到高手C++全方位学习》适合于从未学习过任何编程语言的新手，以及学习C++多年，仍旧不能融会贯通的读者，对于正在使用C++进行开发的程序员也有很好的参考价值。
初识C++1.1
C++简介1.2
C++与C的区别1.3
学习C++之前需要先学C吗1.4
C++与其他语言的区别1.5
C++的版本以及安装问题第2章
做一个最简短的C++程序2.1
简单的屏幕输出小程序2.2
输出语句的使用2.3
std：：介绍2.4
iostream与iostream.h的区别2.5
重名问题2.6
初步了解函数3.1
一个简单的函数3.2
函数的传参3.3
函数的返回值.
参数与变量3.4
函数的声明与定义3.5
局部变量3.6
全局变量第4章
C++数据类型4.1
变量的定义4.2
将变量及数据存储在内存中4.3
布尔型变量4.4
字符型变量4.5
wchar_t双字节型变量4.6
整型概述4.7
整型变量的定义4.8
浮点型变量4.9
枚举型常量第5章
if语句与逻辑运算符5.1
语句的定义5.2
块的定义5.3
表达式的定义5.4
运算符的定义5.4.1
赋值运算符的定义5.4.2
数学运算符的定义5.4.3
赋值运算符与数学运算符的联合5.5
自加与自减5.5.1
表达式的优先级5.7
关系运算符5.8
if语句5.8.1
else语句5.8.2
if语句5.8.3
if语句的嵌套5.9
逻辑运算符及其使用5.9.1
逻辑“与”5.9.2
逻辑“或”5.9.3
逻辑“非”5.9.4
逻辑运算符的优先级5.9.5
运算式的真假关系5.10
三目运算符5.10.1
三目运算符的优先问题5.10.2
三目运算符的使用问题5.10.3
三目运算符的型别问题5.10.4
三目运算符在字符型变量中的使用5.11
复杂嵌套的if语句第6章
面向对象6.1
面向对象程序语言的主要特征6.2
对象和成员6.3
对象和成员的使用方法及区别6.3.1
声明一个类6.3.2
命名习惯6.3.3
定义一个对象6.3.4
类与对象的区别6.3.5
对象与成员的关系6.3.6
不要给类赋值6.3.7
对象只能调用类中存在的成员6.4
成员函数的声明和定义6.7
为什么将成员函数的声明和定义分开6.7.1
普通内联函数6.7.2
成员内联函数6.8
将类声明和定义部分保存在头文件中6.9
const成员函数6.10
构造函数6.11
默认构造函数6.12
析构函数6.13
析构对象数组第7章
循环语句7.1
循环语句的前身――goto语句7.2
慎用goto语句7.3
while语句7.3.1
带运算符的while语句7.3.2
以字符为条件的while语句7.3.3
限定while循环的次数7.3.4
continue语句7.3.5
break语句7.3.6
永不休止的while循环7.4
while循环7.5
for循环7.5.1
灵活的for循环7.5.2
条件为空的for循环7.5.3
执行为空的for循环7.5.4
嵌套的for循环7.6
switch语句7.6.1
switch语句常见错误7.6.2
switch的菜单功能7.7
什么是地址8.2
用指针来保存地址8.2.1
空指针8.2.2
指针与变量类型8.2.3
用指针来访问值8.2.4
指针保存的地址和该地址的值8.2.5
指针对数值的操作8.2.6
更换指针保存的地址8.3
为什么使用指针8.3.1
栈和堆8.3.2
用指针创建堆中空间8.3.3
用指针删除堆中空间8.4
动态内存8.4.1
内存泄漏8.4.2
在堆中创建对象8.4.3
在堆中删除对象8.4.4
访问堆中的数据成员8.4.5
在构造函数中开辟内存空间8.4.6
对象在栈与堆中的不同8.5
this指针8.6
指针的常见错误8.7
指针运算8.7.1
指针的加减运算8.7.2
指针的赋值运算8.7.3
指针的相减运算8.7.4
指针的比较运算8.8
常量指针8.8.2
指向常量的指针8.8.3
指向常量的常指针8.9
什么是引用9.1.1
引用的地址9.1.2
引用就是别名常量9.1.3
引用对象9.1.4
函数的参数传递9.2.1
通过值来传递函数参数9.2.2
通过指针来传递函数参数9.2.3
通过引用来传递函数参数9.2.4
让函数返回多个值9.3
传递对象9.3.1
用值来传递对象9.3.2
使用指针来传递对象9.3.3
使用const指针来传递对象9.3.4
使用引用来传递对象9.3.5
到底是使用引用还是指针9.3.6
引用和指针可以一块用9.4
引用应注意的问题9.4.1
引用容易犯的错误9.4.2
引用一个按值返回的堆中对象9.4.3
引用一个按别名返回的堆中对象9.4.4
在哪里创建，就在哪里释放9.5
总结第10章
深入函数10.1
函数重载10.1.1
普通函数的重载10.1.2
成员函数的重载10.2
函数的默认参数10.3
重载构造函数10.3.1
成员变量的初始化10.3.2
成员变量的初始化与构造函数10.3.3
复制构造函数10.3.4
构造函数和new运算符10.3.5
再谈默认构造函数10.4
析构函数和delete运算符10.4.1
默认析构函数10.4.2
调用构造函数进行类型转换10.5
浅层复制构造函数10.6
深层复制构造函数第11章
运算符重载11.1
运算符重载11.2
在成员函数中实现自加11.3
重载前置自加运算符11.4
创建临时对象11.5
创建无名临时对象11.6
取消创建临时对象11.7
重载后置自加运算符11.8
重载加法运算函数operator+11.9
重载赋值运算函数operator=11.10
转换类型运算符11.10.1
温习调用构造函数实现的类型转换11.10.2
通过构造函数将变量转换为一个对象的成员变量11.10.3
通过operator关键字进行转换11.11
什么可以被重载，什么不可以第12章
什么是继承和派生12.1.1
复杂的继承和派生12.1.2
继承和派生如何在C++中实现12.1.3
继承的种类及语法12.1.4
单一继承12.2
保护型和私有型12.3
访问权限12.4
多重继承12.5
继承的构造与析构12.6
向基类构造函数传递参数12.7
继承和重载的两义性问题12.7.1
多重继承容易产生两义性12.7.2
两义性在重载时的一些问题12.7.3
两义性的归属问题12.7.4
减少两义性产生的混淆问题12.7.5
虚基类不会产生两义性12.8
总结第13章
虚函数13.1
指向对象的指针13.2
虚函数13.3
拳击游戏13.4
继承是否可以实现多态性13.5
在编译时的静态联编13.6
在运行时的静态联编13.7
在编译时的动态联编13.8
在运行时的动态联编13.9
调用虚函数13.9.1
在虚函数中调用成员函数13.9.2
三种调用虚函数的方式比较13.10
被继承的虚函数仍然是虚函数13.11
系统是如何调用虚函数的13.12
在虚函数中使用成员名限定13.13
虚析构函数第14章
数组的基本用法14.1.1
什么是数组14.1.2
数组元素14.1.3
数组下标越界14.1.4
倒序输出14.1.5
将数组的下标定义为常量14.1.6
手动操作数组元素14.1.7
数组的初始化14.2
数组的用途14.2.1
求平均考试成绩14.2.2
兔子繁殖问题14.2.3
数字排序问题14.3
数组在内存中的分布14.4
输出数组名14.5
数组名与函数14.6
传递与接收14.7
数组与函数14.7.1
函数传参实例一――求数组所有元素的和14.7.2
函数传参实例二――用递增法查找数据14.7.3
函数传参实例三――用二分法查找数据14.7.4
函数传参实例四――判断数组是否按照顺序排列14.7.5
函数传参实例五――判断数组排列方式后执行不同的函数14.8
数组在对象中的传参14.9
数组对象14.10
在数组对象中初始化成员变量14.11
指针数组14.12
枚举常量与数组..14.13
多维数组14.14
多维数组的初始化14.15
字符数组14.16
重载数组下标操作符第15章
声明链表结构15.2
简单的图书链表15.2.1
图书链表15.2.2
类的链表15.3
动态链表15.3.1
动态链表的建立15.3.2
解决输入字符造成死循环的问题15.3.3
动态链表的显示15.3.4
动态链表的删除15.3.5
动态链表的插入15.3.6
链表统计15.3.7
使用链表15.4
完整的动态链表清单15.5
链表使用案例――走迷宫15.5.1
创建Windows应用程序项目15.5.2
创建窗口15.5.3
加载图片15.5.4
句柄是什么15.5.5
显示图片15.5.6
动画15.5.7
键盘控制人物移动15.5.8
迷宫墙壁15.5.9
走迷宫15.5.10
用链表记录行走路线第16章
多态性16.1
为什么要使用多重继承16.2
在派生类中增加函数16.3
使用多重继承16.4
多重继承中初始化构造函数的参数16.5
多个子基类共享一个父基类16.6
虚基类16.7
慎用多重继承16.8
空的虚函数16.9
抽象类和纯虚函数16.10
纯虚函数16.11
复杂的抽象结构第17章
类的特殊成员17.1
静态成员变量17.2
私有静态成员变量17.3
静态成员函数17.4
静态成员的使用17.5
函数指针17.6
函数指针数组17.7
函数指针也可以作为函数的参数17.8
使用typedef简化函数指针的声明及定义17.9
类的函数指针17.10
成员函数指针数组第18章
字符串18.1
char型字符串18.2
string型字符串18.2.1
string型字符串的赋值18.2.2
string型字符串的合并18.2.3
string型字符串的部分合并18.2.4
string型字符串的替换18.2.5
string型字符串的复制18.2.6
string型字符串的插入18.2.7
string型字符串的删除18.2.8
string型字符串的查找18.2.9
string型字符串的比较18.2.10
判断string型字符串是否为空18.3
字符串的使用18.3.1
交换两个字符串的内容18.3.2
将string型字符串转为char型字符串18.3.3
char型字符串与函数18.3.4
函数如何返回字符串18.4
结构体18.4.1
结构体的赋值18.4.2
结构体与函数18.4.3
结构体与string18.5
string数组与函数18.6
流的使用18.6.1
重载输出运算符<<18.6.2
友元的方式重载输出运算符18.6.3
重载自加运算符的执行次序18.6.4
重载输入运算符>>18.7
编写一个String类18.7.1
创建String类18.7.2
创建可自动调节大小的String类字符串对象18.7.3
限制数组越界18.7.4
用复制构造函数实现字符串的赋值功能18.7.5
用重载赋值运算符函数实现真正的字符串赋值功能18.7.6
用重载输出运算符operator<<()函数实现字符串的输出18.7.7
用重载输入运算符operator>>()函数实现字符串的输入18.7.8
用重载比较运算符实现字符串的比较18.7.9
为String类添加字符串的相加功能18.7.10
为String类添加字符串的+=功能18.7.11
完成后的String类第19章
代码重用19.1
将String类作为包含类19.3
为book类重载执行相加运算的成员函数19.4
包含对系统造成的消耗19.5
按别名传递book对象19.6
包含指向另一个类的指针19.6.1
数据类Date19.6.2
链表类Node19.6.3
标签类linkelist19.6.4
头节点类HeadNode19.6.5
尾节点TailNode类19.6.6
中间节点InterNode类19.6.7
InterNode类的构造函数19.6.8
InterNode类的插入函数19.6.9
全部程序19.7
中间节点和尾节点合并为一个节点19.7.1
数据类Date19.7.2
由Date类派生的图书类Book19.7.3
由Date类派生的药品类medica19.7.4
创建一个节点类Node19.7.5
用来操作节点类Node的list类19.7.6
list类的getfirst()方法19.7.7
list类的operator[]方法19.7.8
list类的repeat()方法19.7.9
list类的insert()方法19.7.10
list类的find()方法19.7.11
重写的药品管理全部程序19.8
利用类的包含来实现代码重用19.9
私有继承19.10
什么时候使用私有继承，什么时候使用包含19.11
保护继承第20章
友元类与嵌套类20.1
友元类20.2
嵌套类第21章
流的操作21.1.1
缓冲21.1.2
流和缓冲区21.1.3
标准输入输出对象21.1.4
重定向21.1.5
对象代表流21.2
用cout输出21.2.1
重载运算符operator<<21.2.2
清理缓冲区21.2.3
有关输出的相关函数21.2.4
设置输出的字段宽度21.2.5
设置填充字段21.2.6
设置浮点数的显示精度21.2.7
输出末尾的021.2.8
设置标志21.2.9
setf()函数原型21.2.10
所有15个标志以及3个指示标志21.2.11
unset()函数21.2.12
标准控制符21.2.13
iomanip头文件与标准控制符21.3
用cin输入21.3.1
字符串的输入21.3.2
字符串的输入问题21.3.3
get()函数21.3.4
带字符引用参数的get()函数21.3.5
带2个参数的get()函数21.3.6
带3个参数的get()函数21.3.7
getline()函数21.3.8
read()函数21.3.9
gcount()函数21.3.10
peek()函数21.3.11
putback()函数21.4
文件的输入和输出21.4.1
输出数据到文件21.4.2
读取文件中的数据21.4.3
读取空格及空格后面的字符21.5
多种打开文件的方式21.6
检查文件是否打开21.7
二进制文件和文本文件21.7.1
以文本形式输出到文件21.7.2
以二进制形式输出到文件21.8
打开多个文件21.9
命令行处理文件21.10
使用命令行处理文件例程21.11
指定读取文件中的数据21.12
输出数据到文件指定位置处21.13
seekp()和seekg()函数的结合使用21.14
临时文件21.15
sstream字符串输入输出流类第22章
命名空间22.1
什么是命名空间22.2
创建命名空间22.2.1
扩充命名空间的内容22.2.2
尽量在命名空间之外定义函数22.2.3
命名空间中的成员都是公有的22.3
使用命名空间22.4
使用关键字using22.5
为你的命名空间取个别名22.6
未命名的命名空间22.6.1
未命名命名空间与全局变量的区别22.6.2
未命名命名空间与static的区别22.6.3
未命名命名空间.
static与extern的区别22.7
标准命名空间std第23章
什么是模板23.2
重载模板23.3
具体化函数模板23.3.1
函数模板不能重载23.3.2
具体化函数模板解决重载问题23.3.3
具体化函数模板与实例化模板函数23.4
函数模板与具体化函数模板的优先级23.4.1
普通函数和函数模板的执行次序23.4.2
函数模板与具体化函数模板的执行次序23.4.3
具体化函数模板与普通函数的优先级23.5
函数模板的匹配23.6
类模板的定义23.7
复杂类模板23.8
数组模板23.9
对象数组模板23.10
具有多个参数的模板23.11
为模板参数提供默认值23.12
约束模板23.13
模板成员23.14
将模板用作参数23.15
模板和友元23.15.1
非模板友元类和友元函数23.15.2
通用模板友元类和友元函数23.15.3
特定类型模板友元函数23.16
多余的临时对象23.17
静态成员和模板23.18
标准模板库23.18.1
容器23.18.2
顺序容器23.18.3
关联容器23.18.4
算法类23.18.5
总结第24章
异常和错误处理24.1
设置多条catch语句24.3
异常的派生24.4
创建异常类的成员函数24.5
异常类的虚函数24.6
异常类与模板的关系第25章
补充内容25.1
预处理过程25.1.1
预处理指令25.1.2
#include指令25.1.3
#define指令25.1.4
用#define指令替换常量25.1.5
用#define定义一个特定字符串并对其进行测试25.1.6
#define和#endif的用途25.1.7
带参数的#define25.1.8
宏与内联函数25.1.9
#运算符25.1.10
##运算符25.1.11
#undef指令25.1.12
#if指令25.1.13
#endif指令25.1.14
defined指令25.1.15
#ifdef和#ifndef指令25.1.16
#elif指令25.1.17
#error指令25.1.18
#line指令25.1.19
预定义的宏25.3
assert()宏25.4
尝试编写一个简单的assert()宏25.5
不能为0的变量25.6
用宏函数来输出表达式的值25.7
调试的级别25.8
C++类型转换及运行时类型信息(RTII)25.8.1
动态类型转换符25.8.2
静态类型转换25.8.3
重新解释类型转换25.8.4
常类型转换25.8.5
运行时类型信息25.9
关键字volatile25.10
关键字const25.11
关键字mutable25.12
联合数据类型union25.13
联合数据类型的内存占用25.14
匿名联合体25.15
再谈指针25.15.1
指针与数组25.15.2
指针操作多维数组25.15.3
指向多维数组的指针作为函数参数25.15.4
字符串的指针25.15.5
接受字符串指针的函数25.15.6
指向字符串的指针变量与字符数组的区别25.15.7
指向函数的指针25.15.8
指向函数的指针的用途25.15.9
指针数组25.15.10
指向指针的指针25.16
位运算25.16.1
按位与“&”运算符25.16.2
按位或“|”运算符25.16.3
异或“^”运算符25.16.4
取反“～”运算符25.16.5
左移“<<”运算符25.16.6
右移“>>”运算符25.16.7
复合位运算符25.16.8
不同长度数字的位运算25.16.9
位运算的实例25.17
位字段25.18
区域差异25.18.1
locale类25.18.2
默认区域表示或全局区域表示25.18.3
时间与地理设置25.18.4
locale与time.h中时间函数的搭配使用25.18.5
区域表示locale与流的搭配使用25.18.6
区域表示locale与模板的搭配使用附录A
ASCII码对照表附录B
C++的关键字附录C
C++常用头文件列表
从前面几节我们了解了按址传递与按值传递的区别，按址传递可以修改原始变量的值，由于按值传递的是原始变量的副本，因此它不会修改原始变量的值。 假如仅仅是传递变量的话，采用指针或者引用这种按址传递方式的优势不是很明显，但是假如是传递较大的对象的话，这种优势是比较明显的。 这是因为，按值传递在向函数传递一个对象时，会像传递变量那样建立一个该对象的拷贝，而从函数返回一个对象时，也要建立这个被返回的对象的一个拷贝。 假如该对象的数据非常多时，这种拷贝带来的内存开销是相当可观的。比如说该对象拥有1
000多个double型成员变量，每个double型变量占据8个字节，1000个就要占据8000个字节，每次通过值传递的方式给函数传递该对象，都要在栈中复制该对象，占用8000个字节的栈内空间，而返回该对象，又要在栈中复制一次，这样就又要占用8000个字节的内存空间。栈的内存只有2MB大小，8000个字节占用8KB，那么仅仅传递该对象就占用了栈内16KB字节的空间。并且别的对象想要访问该对象的8000个数据成员的时候，也要同样采取复制的方式，那么系统的开销将无法估算了。
《零起点学通c++》的视频在学吧学吧（）和网易学院（）发布后，很快就在各大网站流传开。不少读者给我来信交流c++的学习心得，其中普遍提到的问题是：c+十很难学，他们看了好几本书.有不少地方还是难以理解。c++真的这么难，有必要看很多的教材和资料吗？ 为什么会感到C++难学 c++其实不难学，只是由于许多书的组织框架和表达方式等方面原因无意中增加了学习及研究c++的难度。 就拿众多人推崇为圣经的《c++Primet》来说，与其把它作为一本c++教材来看，不如把它当作c++字典。这是因为该书没有分清主次轻重，在读者不了解模板为何物时，对sTL过早地进行了讲解，而一些相对比较简单的概念.却又放到后面.导致读者要来回跳跃式阅读，类似于查阅字典书。对于初学者来说，这样的字典式图书是不需要的，他们需要的是一本能够循序渐进、快速、扎实地掌握c++语言的图书。 国外书的特点是喜欢用大量晦涩而又抽象的语言来解释一个概念，而要理解这些概念.又需要查阅其他相关书籍。当你彻底明白作者的意图时，你不禁错愕，这些晦涩而又抽象的语言完全可以用一句简单话来代替。 这是因为中国人和外国人在思维和表达上不同，外国人喜欢用抽象的语言来解释抽象的概念.这是他们几百年来养成的习惯。习惯了形象思维的中国读者在阅读他们的书籍时自然会不适应，这就在无形中增加了我们学习c++的难度。
正在加载中，请稍候...
正在加载中，请稍候...
正在加载中，请稍候...
正在加载中，请稍候...
正在加载中，请稍候...
正在加载中，请稍候...
正在加载中，请稍候...
七日畅销榜
新书热卖榜C++实验报告11_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
13页免费17页免费6页免费7页免费33页免费4页免费4页免费5页免费4页免费2页免费
喜欢此文档的还喜欢29页2下载券20页2下载券14页免费3页1下载券18页3下载券
C++实验报告11|
把文档贴到Blog、BBS或个人站等：
普通尺寸(450*500pix)
较大尺寸(630*500pix)
你可能喜欢1112人阅读
C++中对类对象（抽象数据类型实例）的操作通过向对象发送消息完成，使用C++的操作符链接用户自定义类型对象的过程叫做操作符重载，编译器在处理表达式时，会根据操作符的使用方式生成合适的代码。
& C++强大的功能不仅在于用户可以自己定义新的类型，还表现在允许重载现有的大多数操作符，使这些操作符可以与类对象结合使用，给操作符赋予新类型的含义。
& 操作符重载通过编写函数定义实现，被重载的函数名格式为operator+运算符，作用于类对象的操作符必须进行重载，有以下两个例外：
& 1.赋值操作符无需显式重载就可以作用域每一种类型，默认行为是为类的数据成员赋值，这种默认的行为对含有指针类型的数据成员的类是危险的，对于含有指针数据成员的类，赋值操作符必须进行重载；
& 2.地址操作符无需重载就可以英语与各种类对象，返回对象的内存地址，地址操作符也可以进行重载。
& 可以重载C++内部定义的操作符，这样可以为用户自定义的类型提供简洁的表达式，必须手动编写操作符重载函数，这些函数可以作为成员函数，也可以作为友元函数。
& 一些限制：
& a.不改变优先级
& b.不改变结合性
& c.不改变操作数的个数
& d.不改变作用域内部类型的方式
&& 操作符重载只能随用户自定义类型的对象一起使用，或者随用户自定义类型的对象和内部类型对象混合使用，这样可以防止改变作用域内部类型的方式。
& &操作符只能够显式重载，要保证相关操作符的一致性，可以用一个操作符实现另一个操作符。
& 2.类成员函数和友元函数
&&&在重载操作符()[]-&或者任何赋值操作符时，操作符重载函数必须声明为类的一个成员；
&& 如果操作符的左操作数是类的对象或者类对象的引用&，才可以用成员函数实现，如果左操作数不是类的对象，也不是类对象的引用，则只能用一个非成员函数实现，如流插入操作符和流读取操作符。
&& 只有当二元操作符左操作数是该类的一个对象，或者一元操作符的操作数是该类的一个对象时，才有必要定义为类的操作符成员函数。
&& 选择非成员函数重载操作符的另一个原因是使操作符具有可交换性。
&&& (1)重载流插入和流读取运算符
&&&& a.这两个运算符本身可以处理char*字符串和指针在内的各种内部数据类型；
&&&& b.这两个操作符重载函数只能够定义为类的友元函数
&&&&& friend ostream & operator &&(ostream & output,const PhoneNumber &);
friend istream & operator &&(istream & input,PhoneNumber &);
操作符重载函数包含两个参数，一个是对istream/ostream的引用，另一个是对用户自定义类型的引用，当编译器遇到语句
& cin&&phone时，编译器将生成函数调用operator&&(cin,phone)
同样，编译器督导cout&&phone时，编译器将生成函数调用operator&&(cout,phone)
(2)重载一元操作符
& 可重载为无参数的非静态成员函数和有一个参数的非成员函数，参数必须是用户自定义的类对象或者对象的引用，实现操作符重载的成员函数应该定义为非静态类型，以便访问类的非静态数据，静态函数只能够访问类的静态数据。
& 重载一元操作符时，要将重载函数定义为成员函数而非友元函数，这样可以避免破坏类的封装性。
(3)重载二元操作符
&& 可以重载为带一个参数的非静态成员函数，也可以重载为带两个参数的友元函数，其中一个参数是类对象或者类对象的引用，一般情况下，如果操作符的左操作数是类对象或者引用，则定义为成员函数比较好。
(4)拷贝构造函数
&& 下标运算符的重载函数需要返回值的引用，这样可以作为左值，进行赋值。
&& 需要复制对象时，需要调用复制构造函数，通过建立对象的副本（拷贝），初始化相同类型的对象（构造函数），必须谨慎对待拷贝构造函数，避免两个对象指向同一个动态分配的存储区，需要复制对象时，都需要创建拷贝构造函数
&& 复制构造函数应使用引用调用，而非传值调用，否则复制构造函数会出现无穷递归，因为对于传值调用，建立传入复制构造函数的对象副本会造成复制构造函数的递归调用。
& 如果构造函数仅把源对象的指针复制到目标对象的指针，这两个对象将指向同一块动态分配的内存块，执行析构函数释放该内存块，结果将导致另一个对象的ptr没有定义。
& 类的对象包含的指向动态分配的内存的指针，如果不为其提供重载的赋值操作符和复制的构造函数会造成逻辑错误。
& 防止类对象被复制是能够实现的，只须令重载的赋值操作符和复制构造函数为private即可。
& 对于下标运算符的处理，数组中相应下标的元素作为引用返回，以便能够作为左值，而在常量版本的情况下返回右值。
(5)类型转换
&&&a. 实现用户自定义类型和内部类型之间的转换，这种转换可以用转换构造函数实现，使用带单个参数的构造函数，这种函数的功能是将其他类型的对象转换为某个特定类的对象。
&& b.转换操作符，把一种类的对象转换成其他类的对象或者内部类型的对象，强制类型转换操作符只能够是非静态的成员函数，不能够是友元函数
&&&& 如A::operator char *()
&&&& 声明了一个重载的强制类型转换操作符函数，根据用户自定义类型A的对象建立一个临时的char*类型的对象，如果s是某个类的对象，编译器遇到表达式char*时，会产生函数调用s.operator char*(),操作数是调用成员函数operator char*的类对象s
&& 强制类型转换操作符和转换构造函数在需要的时候，编译器会自动地调用这些函数建立临时对象
&& cout&&s
编译器会调用强制类型转换操作符函数operator char*将对象转换为char*，并在表达式中使用char*的结果，任何只含一个参数的构造函数都可以认为是一种转换构造函数，转换构造函数意味不必为将字符串赋值给String类型对象提供重载的赋值操作符，编译器会调用该函数建立包含该字符串的一个临时String对象，然后调用重载的赋值操作符将临时String对象赋给另外一个String对象
& c.函数调用操作符
&& String operator()(int,int)
& 重载函数调用操作符，重载函数调用操作符只能是非静态成员函数，只有当“函数名”是String类型的对象时，才能使用该操作符。
String String::operator()(int index,int subLength)
assert(index&=0&&index&length&&subLength&=0);
if(subLength==0 || length-index&subLength)
len=length-
char *tempPtr=new char[len+1];
assert(tempPtr!=0);
strncpy(tempPtr,&sPtr[index],len);
tempPtr[len]='/0';
String tempString(tempPtr);
delete[] tempP
return tempS
该函数的定义实例如下，调用方式为，s(4,10)，其中s为String类型的对象。
d.重载 ++和--
重载前置的方法与重载其他前置一元操作符一样
编译器在执行++dl时，会生成成员函数调用dl.operator++()
& 该函数原型为Date&operator++()
&&&&&&&&&&&&&&&&&&& friend Date&operator++(Date &)
& 编译器在遇到后置自增表达式d++时，生成成员函数调用dl.operator(0)
& 该函数的函数原型为Date operator++(int)
&&&&&&&&&&&&&&&&&&&&&&&&&&&& friend Date operator++(Date &,int)
& 0只是一个伪值，使操作符函数operator ++在用于后置自增操作和前置自增操作时的参数表有所区别
& 前置使对象值增加1，返回的是自增后的对象，后置也是对象值增加1，返回的是自增前的值。
试比较如下两段代码
Date &Date::operator ++()
helpIncrement();
Date Date::operator ++(int)
Date temp=*
helpIncrement();
对象都执行了自增操作，不同的是，前者返回的是执行自增操作之后的对象，后者保存自增之前的值，并返回自增之前的值。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：53382次
积分：1191
积分：1191
排名：第16040名
原创：68篇
(1)(1)(2)(7)(1)(1)(1)(11)(11)(10)(27)
