第一章 C++程序设计基础
1.1 简单的C++程序举例
1.使用头文件
#include <iostream>
using namespace std;
2.注释
//........
/*
............
*/
1.2 C++变量与常变量
1.变量
变量赋值
1）int a;
a=12;//赋值语句初始化
2)int a=12;//定义变量并初始化
2.常变量
例子：const double pi = 3.14159;
注意：1.必须在定义时，赋初值
2.程序运行中，值不变
3.符号常量
例子： #define PI 3.1415926
好处：便于系统修改
1.3 文字常量
1.整型常量
1）十进制整数
如 789，-234
2）八进制整数（零 开头）
如 0123, -023
3）十六进制整数 (零0 x/X 开头)
如 0x233, -0x22
4）长整型
如 12L , 0234L , -0XABl (L/l 都行)
5）无符号型
如 12U ， 0234U , 0xABu (U/u都行)
2.实型常量
均是十进制数，两种形式：
1.小数形式： 1.65 ,1. ，.123
2.指数形式：1.23e4 , 1.23e-7 , 1e3
3.字符型常量
char型，'a' 'A'
4.转义字符
\b 退格（回到上一格）
\n 换行 \t Tab键 \' / \’‘ 单/双引号 \r回车符
\nnn 八进制值 \xhh 十六进制值，最多两位
5.字符串常量
"123"
"i am wangbiao"
"a"
串结束符：'\0'
注意：”a"和’a‘不同
1.4 C++运算符
1.算术运算符和算术表达式
1）算术运算符： + - * / %
%只能为整数
2）<变量>=<表达式>
2.赋值运算符和赋值表达式
a += 3
y *= (x+8) <=> y=y*(x+8)
3.自增、自减运算
++i i++
--i i--
i为变量，不能为常量或表达式
4.关系运算符和关系表达式
< <= > >=
== !=
以上运算结果为bool型
5.逻辑运算符和逻辑表达式
！ && ||
以上运算结果为bool型
非0表示true，0表示false
1.5 位运算
1.按位与（&）
化为二进制数，1&1等于1,其它三种等于0
2.按位或（|）
化为二进制数，0|0等于0，其它三种等于1
3.按位异或（^）
化为二进制数，1^1或者0^0 等于0,1^0或者0^1 等于1
4.按位取反（~）
化为二进制数，0变1,1变0
5.左移（<<）
例子：int a= 15,x=a<<3;
a化成二进制，左移3位，右边新添的3位为0
6.右移（>>）
与左移相似
1.6 cin和cout基本输入和输出
1
cin/cout：输入/输出流对象
>> 流提取操作符
<< 流插入操作符
2指定输入域宽
char word[10];
方法1：
cin>>setw(10)>>word;
方法2：
cin.width(10);
cin>>word;
3读取一行
char s[81];
cin.getline(s,81);
cout<<s<<endl;
4读取一个字符
cin.get(ch);
5读取字符时易出错的地方
cin.ignore();
1.7枚举类型
1.类型定义，例如
enum weekday {Sun,Mon,Tue,Wed,Thu,Fri,Sat};
或者enum weekday {Sun=7,Mon=1,Tue,Wed,Thu,Fri,Sat};
2.变量定义，例如
enum weekday day1,day2;
enum weekday {Sun,Mon,Tue,Wed,Thu,Fri,Sat} day1,day2;
第二章 C++流程控制
2.1 算法的基本概念和表示方法
1. 概念
算法：为解决某特定问题而采取的正确且有限的步骤。
特性：1）有穷性 2）确定性 3）零或多个输入 4）零或多个输出 5）有效性
2. 算法的三种基本结构
1.顺序结构
2.选择结构
3.循环结构
2.2.选择结构程序设计
1. if-else语句
基本格式：
if(表达式) 语句1; else 语句2;嵌套格式：
if(表达式1) 语句1; else if(表达式2) 语句2; ...... else if(表达式n) 语句n; else 语句n+1;if(表达式1) if(表达式2) 语句1; else 语句2; else 语句3;2. 条件表达式与switch语句
条件运算符：
<表达式1>?<表达式2>:<表达式3>switch表达式：
switch (<表达式>) { case <常量表达式1>: 语句序列1; [break;]//break看情况加 ...... case <常量表达式n>: 语句序列n; [break;] [default: 语句序列n+1; [break;]]//default看情况加 } //注意：<表达式>和<常量表达式>类型：字符型，整型，枚举型和布尔型。 // 不能取实型。 // 语句序列可为多条语句
2.3 循环结构程序设计
1. while语句
格式：
while(表达式) 循环体结构语句;2. do-while语句
格式：
do 循环体语句; while(表达式);3. for语句与循环嵌套
for语句格式：
for([初始化条件];[条件];[更新]) 循环体;for语句循环嵌套格式：
for([初始化条件1];[条件1];[更新1]) for([初始化条件2];[条件2];[更新2]) 循环体;4. break与continue
对于上面三种循环，可用break语句跳出循环以及continue语句结束本次循环。
第三章 函数
3.1 函数的定义和调用
1. 函数的分类
库函数（只有调用相关头文件即可）
用户自定义函数
2. 一般形式
<类型> <函数名> (<参数列表>) //无参数时，括号仍在 { <函数体> }3. 调用函数
格式：
<函数名>(实际参数表)；
4. 函数的原型声明
c++满足：“先定义，后使用”的原则。即放在函数调用前面！！！
函数原型：函数类型、函数名、形参个数及其原型。
格式：
<类型说明符> <函数名>(<参数表>)//格式1 <类型说明符> <函数名>(<参数类型表>)//格式2
3.2 函数的参数传递和返回值
1. 参数传递
函数调用时，先将实参的值按照位置传递给对应的形参
实参与形参的个数一一对应且类型匹配
实参与形参的名字可以不相同
c++有两种参数传递：传值和传引用（&）
2. 函数的返回值
对于无返回值类型（void），调用的函数执行完，调用函数终止并返回到调用者，然后调用者继续程序的执行。
对于有返回值的函数，必须要用 return语句 返回给调用者·。
格式：
return 表达式;
3.3 局部变量和全局变量
1. 基本概念
局部变量：仅在某些函数或代码段中可见的变量。
全局变量：使整个程序中都可见的变量。
2. 其它细节
如果：局部变量和全局变量同名时，局部定义优先！此时该函数内需要访问全局变量时，变量名前加域运算符（::）
3.4 变量的存储类型
变量的存储类别
存储类别修饰符：
auto、register、static和extern
auto（可不写）和register修饰自动存储变量
static修饰静态存储变量
extern修饰外部存储变量
3.5 默认参数及内联函数
1. 默认参数
也叫缺省参数，用在：函数调用时，省略了函数实参，那么将把缺省参数的值赋给函数形参。
缺省参数一般放在函数原型中，并且集中在右侧。
2. 内联函数
解决：频繁的函数调用降低程序的效率问题。解决时间的开销。
关键字：inline
可以用在函数定义和声明处（依然按照函数“先定义后使用”的原则）
内联函数内不允许出现 循环语句、switch语句及复杂嵌套的if语句。
3.6 函数重载
程序中定义多个函数，函数的名字相同，但参数类型或个数不完全相同。
注意1：不能使用返回值区别重载
注意2： c++进行函数调用时，不仅靠函数名识别函数，还要看参数列表
3.7 函数模板
定义形式：
template <类型参数表>//1)typename <参数名> 2)class <参数名> 3)<数据类型> <参数名> 返回值类型/*参数名*/ 函数名/*模板形参*/(形式参数表) { //函数体 }
3.8 函数的递归调用
定义：一个函数直接或间接调用自身。（应该有终止条件）
3.9 编译预处理
定义：编译器在对源程序正式编译之前，对源程序进行的 文字上的 处理工作。
三种预处理：
宏定义
1）不带参数的宏定义 #define 宏名 字符串 例子：#define PI 3.14
2）带参数的宏定义 #define 宏名(参数表) 字符串 例子：#define MUL(x,y) (x)*(y)
注意：宏定义写在多行时，应使用续行符（“\”）；
使用有参数的宏定义时，参数表不能与宏名分开。
文件包含
格式：
#include <文件名>//格式1，一般用于嵌入系统头文件 #include "文件名"//格式2，一般用于用户自定义的头文件
条件编译
定义：仅编译源程序中满足条件的程序段，使生成的目标程序段较短，从而减少程序运行时的内存开销并提高程序的效率。
第四章 数组
4.1 一维数组
定义：
例：
int array[5];//int 数据类型；array 数组名；5 数组元素个数 //下标范围0~4初始化：
int a[3]={0,1,2};//全部元素赋初值 int a[3]={0,1};//部分元素赋初值，其余默认为0 int a[3]={}={0,1,2};//全部元素赋初值时，可以不指定长度
4.2 二维数组
定义：
例：
int array[5][6];//int 数据类型；array 数组名；[5] 数组行数；[6] 数组列数初始化：
int a[2][3]={{0,1,2},{3,4,5}}; int a[2][3]={0,1,2,3,4,5};//按数组元素排列赋初值 int a[2][3]={{0},{3,4}};//对部分元素赋初值，其余元素默认为0 int a[][3]={0,1,2,3,4,5};//可自动确定数组行数（以省略行数，不能省略列数）
4.3 数组做函数参数
1.数组元素做参数（与普通参数一样）
2.数组名做参数
4.4 字符数组与字符串
定义：
例：
char str[4]; char str[4][5];初始化：
例：
/*字符数组*/ char name[5]={'w','a','n','n','a'}; char name[5]={'w','a','n'};//部分赋初值，其余默认为'\0' char name[]={'w','a','n','n','a'}; char name[2][5]={{'w','a','n','n','a'},{'w','a','n'}}; /*字符串*/ char name[10]={"wanna"}; char name[10]="wanna"; char name[10]={'w','a','n','n','a','\0'};字符数组的输入输出：
/*单个字符一个一个输入输出*/ char name[5]; for(int i=0;i<5;i++) cin>>name[i];//不能输入空格、跳格、换行等 cin.get(name[i]);//此法不用考虑上面问题 for(int i=0;i<5;i++) cin>>name[i]; /*字符串整体输入输出*/ cin>>name; cout<<name;//只有字符串才能整体输（例：整型数组，字符数组都不行）
4.5 处理字符的宏
例：
/*要包含头文件才能使用*/ isalpha(ch)//如果ch是字母，返回true，否则false isdigit(ch)//如果ch是数字字符'0'~'9'，返回true，否则false isupper(ch)//如果是大写字母，返回true，否则false islower(ch)//如果是小写字母，返回true，否则false toupper(ch)//如果ch是字母，则返回对应的大写字母，否则原样输出 tolower(ch)//如果ch是字母，则返回对应的小写字母，否则原样输出
4.6 处理C风格字符串的函数
1. 求字符串长度
char s[]="I am Wanna"; cout<<strlen(s);//输出是s[]的字符长度，遇到'\0'结束（与sizeof(s)的区别）。2. 字符串拷贝函数
char s1[80]={"I am Wanna."}; char s2[80]; strcpy(s2,s1);//将s1拷贝到s2，注意s2大小 strncpy(s2,s1,10);//将s1的前10个字符 拷贝到s2 s2[10]='\0'//s2字符串结束标志3. 字符串连接函数
char s1[20]="I am "; char s2[20]="Wanna"; strcat(s1,s2);//将s1和s2连接起来（s1空间要足够大）4. 字符串比较函数
char s1[10]="I am"; char s2[10]="Wanna"; cout<<strcmp(s1,s2);//通过比较从左至右的字符的ASCLL码值。输出结果分别为1,0，-1 cout<<strncmp(s1,s2,1)//比较s1和s2中第一个字符的ASCLL码值5. 大小写字母互变函数
char s[20]="I am Wanna"; cout<<strlwr(s)<<endl;//s中大写变成小写 cout<<strupr(s)<<endl;//s中小写变成大写6. 查找子串的函数
char s[20]="I am Wanna"; char s_[]="am"; cout<<strstr(s,s_)<<endl;//返回第一次出现的位置（地址）7. 字符串转换为整数的函数
char s1[80]="12345"; char s2[80]="678X90"; int i=atoi(s1);//输出12345 int j=atoi(s2);//输出为678，X后面（包括X）都没了8. 整数转换为字符串的函数
int n=123; char s1[20],s2[20]; itoa(n,s1,3);//s1中存储的是八进制表示的串"11120" itoa(n,s2,10);//s2中存储的是十进制表示的串"123"
4.7 标准的C++的string类
如何使用string类型：
1.包含头文件
#include <string>2.定义对象
string name; cin>>name; cout<<name; getline(cin,name);// 读取一行string对象的比较
两个string对象 或者 一个string对象和一个字符串 可以直接进行比较（采用<、>、<=、>=、==和!=）。结果为真，输出1；为假，输出0
string初始化
例：
string name("wanna"); string person(name); string s1(s2,5); string name(fullname,0,7);支持常用的操作符
=、+=、+、[ ]
例：
str3=str1+str2; str3+="abc";
第五章 指针
5.1 指针的概念及指针变量的定义和使用
1. 概念
指针：指向值所在地址的首地址
指针变量：存放指针（或地址）的变量，其内存单元中存放的是地址
2. 定义指针变量
格式：类型说明符 *指针变量名；
例如：
int *pInt char *pChar 注意： 1.如果指针变量为0(NULL),表示空指针 2.地址1000和整数1000不同 3.任何类型的指针都占4个字节的内存空间3. 运算符& 和 *
1. &：取内存变量地址 char *p,ch='a'; p=&ch; 2. *:通过指针 间接访问所指变量 char p,ch1='a',ch2; p=&ch1; ch2=*p; *p='b';
5.2 指针与一维数组
1. 指针与数组
访问数组的方式：下标形式和指针形式
2. 指向一维数组元素的指针
数组名代表该数组的开始地址，因此数组名是一个 指针常量 ，例如： int a[10],*p; p=&a[0];//或p=a 则p、a、&a[0]是一个值。3. 指针的运算
1. 指针+/- 整数值 例如： int a[10],*p1,*p2; p1=&a[2]; p2=p1+3; 2. 指针相减 例如： int *p1,*p2,n,a[]={2,4,6,8,10}; p1=&a[1]; p2=&a[2]; n=p2-p1; //地址相减 3 n=p1-p2; -3 注意：1.两指针指向同一数组 2.指针变量之间的 加法 运算无意义 3.指针比较：指向同一数组的两个指针可进行的比较包括：== != < <= > >=
5.3 指针与二维数组
二维数组元素a[i] [j]的地址及元素表示：
a[i][j]的: 1. 地址可表示为： &a[i][j] 、 a[i]+j 、*(a+i)+j //a[i]==*(a+i) 2. 元素表示为： a[i][j] 、 *(a[i]+j) 、*(*(a+i)+j) 、(*(a+i))[j]行指针变量：
int a[3][4],（*pa)[4]=a;//4表示指向的一维数组的元素个数
5.4 指针与函数
1. 函数参数的传递方式
传值调用：变量的值；变量的地址值 传引用2. 返回 指针值 的函数
指针型函数：函数的返回值 为某种数据类型的地址值，即指针类型数据
格式： <数据类型> *<函数名>（[<参数表>]） { <函数体> } 例如： int *fun(int x,int y) {.....}3. 函数指针的定义
函数的指针： 函数的入口地址（函数名表示首地址）。
函数指针变量： 定义一个变量， 指向 函数 的入口地址。
指向函数的指针变量的定义形式：
<数据类型> (<*函数指针名>)(<参数类型表>) 例如： int (*fun)(int,int); int max(int x,int y) { return x>y?x:y; } fun=max; 此时调用max方法： k=max(10,20); k=(*fun)(10,20); k=fun(10,20);
5.5 指针数组与指向指针的指针
指针数组：int *p[10]; int a=10,*p,**pp;//指向指针的指针 *p=&a; pp=&p;
5.6 内存的动态分配和释放
new :动态申请存储空间 delete :释放有new申请的存储空间 如果函数的参数是一个指针，不要用该指针去申请动态内存
5.7 void 和 const 修饰指针变量
void 修饰指针（代表一种不确定类型的指针） 1. 任何类型的指针都可直接赋给它，无需类型转换 2. void 指针不能进行算术操作 const 修饰指针 1.指向 常量 的指针：可以改变指针所指的空间，但不可以通过指针改变现在所指的 内容） 例如： int i=6; const int *p1=&i; const int m=30; const int *p2=&m; p1=&m; 2.常量 指针：可以改变 内容，不能改变 指针的指向 例如： char str[10]="abcd"; char *const p=str; *(p+1)='t'; 3.指向 常量的 指针常量：不可以改变 内容和指针的指向 int i=100; const int *const p=&i;
第六章 结构体
6.1 结构体的定义
1. 定义
结构体属于 用户自定义 类型，必须先定义数据类型，然后再定义该类型的 变量。
struct <类型名字> { <成员列表>; };//分号不能 省略2. 定义结构体类型的变量
1.先定义结构体类型在定义变量 例如： student Bob,Alice;//或者 struct student Bob,Alice; 2.在定义结构体类型的同时定义变量 struct student { int ID; char name[20]; char gender; date birthday; //使用其他 结构体 的类型date double score[3]; }Bob,Alice;3. 初始化
1.用花括号{} student Bob={111,"Bob",'m',{2002,9,15},{90,89,78}}; 2.用同类型的结构体 变量 去初始化 student Alice=Bob;4. 结构体变量成员的引用
1.引用 结构体变量的 成员 例如： Bob.ID=222; 2.整体引用 student Bob={111,"Bob",'m',{2002,9,15},{90,89,78}}; student Alice; Alice=Bob; 主要：不能整体输入5. 结构体 指针做变量
student *ps; student Bob; ps=&Bob; ===> Bob.name<=>ps->name<=>(*ps).name
6.2 结构体数组与指针
1. 定义结构体数组
student stud[4];2. 使用结构体数组
引用元素： for(int i=0;i<4;i++) cout<<stud[i].name; 指针： student *ps; ps=stud; for(int i=0;i<4;i++) { cin>>ps->ID; ps++; }
6.3 用 typedef 定义类型名
定义的格式
typedef <类型名1> <类型名2>; 例如： typedef int Workday; Workday day;//<=>int day; typedef struct person { char name[20]; int age; }Person; //Person 是新的类型名 Person p1,p2; 注意：typedef是将已知数据类型名 定义 新的名字，没有增加新的数据类型 typedef 应用与软件移植
第七章 文件操作
7.1 文件的打开与关闭
1. 使用文件的过程
1.打开文件 2.对文件进行读或写操作 3.文件操作完以后关闭文件 文件流 类型 #include <fstream> //文件流 #include <ifstream> //文件输入流，只能读取 文件 #include <ofstream> //文件输出流，只能写 文件2. 文件打开
ifstream file; file.open("d:\\hello world.text"); 或者 char fileName[20]; cin>>fileName; fileName.open(fileName); 几种模式： ios::app 追加 ios::ate 如果已存在，转到文件尾部 ios::binary 二进制形式 ios::in 读 iOS::out 写 ios::nocreat 若文件不存在，则不能创建 ios::noreplace 若文件存在，则失败 iOS::trunc 若文件存在，删除其内容 例： fstream file; file.open("d:\\hello world.text",ios::in|ios::out); 或者 fstream file.open("d:\\hello world.text",ios::in|ios::out);3. 测试文件是否打开
if(!file) { cout<<"打开失败\n"; exit(0); }4. 关闭文件
file.close();
7.2 文件的输入输出
1.使用 <<写文件
file<<"hello"; file<<"world"; 文件内写入了，helloworld。2. 文件格式化输出
3. 采用>>从文件读数据
4. 检测文件结束
if(file.eof()) file.close(); eof ==》 end of file5. 采用成员函数读写文件
file.getline(str,81,'\n'); 从文件读取的数据放在 str 文件最大读取80个字符 80 '\n' 在读满之前，遇到该字符，停止读取 file.get(ch);//读取一个字符 file.put(ch);//写入一个字符
7.3 多文件操作
whlie(!file1.eof())
{
file1.get(ch);
if(file1.fail())
break;
ch2=toupper(ch);
file2.put(ch2);
}//将file1 的内容 写到file2中，并且里面的小写字母转换成大写字母
7.4 简单的二进制文件
1. 以二进制方式打开
file.open("d:\\hello world.text",ios::in|ios::out|ios::binary);2. 二进制文件的读写函数
fstream file; int buffer[]={1,2,3,4,5,6,7,8,9,10}; ...... file.write((char *)buffer,sizeof(buffer)); file.read((char *)buffer,sizeof(buffer));
7.5 随机访问文件
seekp 用于 输出文件 （写，put） seekg 拥有 输入文件 （读，get） 例子： file.seekp(20L,ios::beg); 文件随机访问模式： ios::beg 从文件头 开始计算 偏移量 ios::end 从文件尾 开始计算 偏移量 ios::cur 从当前位置 开始计算 偏移量 tellp 用于返回 写位置 tellg 用于返回 读位置 例子： pos1=file.tellp(); pos2=file.tellg();
第八章 类的基础
8.1 类的基本概念
类是一种用户自定义类型，形式如下：
class 类名
{
变量和函数的声明;
....
};
定义成员函数：
<返回值类型> <类名>::<函数名>(参数列表)
{
......
}
定义对象：
<类名> 对象名;
对象名.<函数>；
8.2 类的多文件组织方式
将 定义类 放在.h 文件 将 成员函数 放在 .cpp文件 将 对象实例化 放在 main文件 调用时，要加 头文件 上面方式没强制要求，但最好这样。 类的公有成员函数 可以调用 私有成员函数成员和私有数据成员 内联函数： 形式1：直接在类里面，定义函数 形式2：在类外定义，前面加上 inline 。（这里的 函数 和 “定义类” 的文件 是同一个，不然报错） 要求：1：函数体要简单 2：函数体内部 没有循环，不能有 switch等复杂结构
8.3 构造函数和析构函数
构造函数： 1.是与类 同名的函数成员 2.无返回值类型 3.允许做 内联函数、重载函数、带缺省形参值的函数 4.定义对象时，自动 调用 此函数 析构函数： 1.是与类 同名的函数成员，但前面 加一个 '~' 符合 2.无返回值类型，无参数 3.当一个对象终止时，系统 自动调用 此函数 对对象 做“善后”处理
8.4 重载构造函数
函数名相同（都是构造函数名），参数不同 调用时，按照 对象的参数 调用相应的 构造函数 并且 不能有两个缺省构造函数 对象数组： 1.创建对象数组时，数组中的 每一个元素（对象），都将调用构造函数 2.如果 数组元素没指定初始值（或者该元素没被写出来），则 调用 缺省构造函数，用其的 缺省值 初始化 3.函数中每一个 对象被删除时，都要调用 析构函数
第九章 类的高级部分
9.1 静态成员
特点： 1.用关键字 static 声明，同一类中的所有对象都 共享 该变量 （例子：（在类内）static int x;） 2.必须在 类外 定义和初始化，用 :: 来指明所属的 类。（例子：int 类名::x; //x默认为0） 3.无论是否定义 该类的对象，这种变量都存在 4.生命周期与 整个程序的生存期 一样，在定义对象前，就已经存在
9.2 静态函数成员
特点： 1.是类中的一个函数，前面加上 static 修饰 2.在生成对象之前，就已存在。 即使不定义对象，它也能访问其它静态成员 3.类外的代码 可以使用 类名和作用域操作符号（::）来调用静态函数成员 4.静态函数成员 只能 使用该类的 静态数据成员 和 静态函数成员
9.3 友元函数
特点： 1.友元函数 不是 类中的成员，但它可以访问 类中 的私有成员 2.友元函数 可以为 一个外部函数，也可以为 另一个类的成员函数 3.声明 友元： 前面加 friend （例子：(在类里面加）a.friend int max(); b. friend class B; c. friend void B::set(int x); ）
9.4 对象赋值问题
采用赋值运算符（=），将一个对象 赋值给 另一个对象，或者 采用一个对象 初始化 另一个对象。 在缺省情况下，这两个操作 执行的是对象成员之间的拷贝，称为浅拷贝或按位拷贝。 例子： Rect A; A.max(100); Rect B=A;//初始化 Rect B(A); Rect A,B; A=B;//赋值
9.5 拷贝构造函数
定义： 它是一个特殊的构造函数，采用一个对象去初始化 另一个对象时，自动调用。解决一个对象初始化另一个对象时，指针被释放的问题（当数据成员有指针类型时，一般要自己定义拷贝构造函数） 调用： 1.用 对象初始化同类型的另一个对象 ，将调用 2.如果 函数的形参 是对象，当进行参数传递时，将调用 3.如果 函数的返回值 是对象，函数执行结束时，将调用拷贝构造函数 对 无名临时对象 初始化
9.6 赋值运算符重载和 this指针
赋值运算符重载：
解决：对象中指针成员不能对象赋值的问题
例子：
void operator = (......)
{
.....
}
p1.operator = （p2）; //<----p1=p2;
this指针
是隐含的 内嵌指针，它调用 成员函数 的 当前对象。
解决：对象赋值中的 p3=p2=p1;(承接上面)
9.7 +运算符重载
任何一个 双目运算符O 被重载以后，当执行二目运算时： o1 B o2 《=》 o1.operator B (o2) 常见的 B 有：+、-、*、/、+= 例子： Rect L1,L2,L3; L3=L1.operator +(L2);// 解决：L3=L1+L2;(X)
9.8 ++运算符重载
例子： d2=++ d1;//前置++ 《=》d2=d1.operator ++(); d2=d1 ++;//后置++ 《=》d2=d1.operator ++(0);
9.9 关系运算符重载
实现两个对象的 比较，返回值为 bool类型。 例子： d1>d2; 《=》d1.operator >(d2);
9.10 流运算符（>>和<<）重载
必须通过 友元函数的 形式 实现重载。 例子： cout<<f1; 《=》operator << (cout,f1); cin>>f1; 《=》operator >> (cin,f1);
9.11 类型转换运算符重载
对于一个 对象 ，通过重载类型转换函数，可实现 类型转换。
例子：
operator float();//无返回值类型。
类名::operator float()
{
....
}
定义对象：
类名 aa(3,6);
float f;
f= aa;
9.12 重载 [ ]运算符
int &operator[ ](const int &);//括号内，指 数组 下标
注意： 不能重载的运算符(5个)： ?: . .* :: sizeof
第十章 继承、多态和封装
10.1 继承
子类不能访问基类的私有成员。在公有继承或者保护继承的情况下，子类能访问基类的保护成员。 私有继承：私有成员不可访问。基类保护和公有成员 在子类变成 私有的 保护继承：私有成员不可访问。基类保护和公有成员 在子类变成 保护的 公有继承：私有成员不可访问。基类保护和公有成员 在子类 的属性不变 class Test :Grade (:后面没写继承修饰符，默认private继承) 继承下的构造函数和析构函数的调用顺序 构造函数：定义一个子类对象，先调用父类的构造函数，再调用子类的构造函数 析构函数：定义一个子类对象，先调用子类的析构函数，再调用父类的析构函数
10.2 初始化列表
1、如果类之间有继承关系，子类必须在其初始化列表中调用父类的构造函数
例子：
class Bass
{
Base(int x);
};
class D:public Base
{
D(int x,int y):Base(x)
{ /*.....*/}
};
2、类中的const常量只能在初始化列表中进行初始化，而不能在函数体内用赋值的方式来初始化
3、对象类型的成员在初始化列表初始化的效率高；基本类型变量（int...）效率没区别
10.3 覆盖
1.一定出现在具有继承关系的基类和子类之间
2.函数名、参数个数、参数类型 要完全相同
3.进行调用时， 子类对象所调用的 是子类中定义的函数
4.覆盖 是C++多态性的表现
例子：
class Base
{
public:
int fun(int x)
{cout<<x;}
};
class D:public:Base
{
public:
int fun(int x)
{cout<<x+y;}
}
10.4 虚函数和纯虚函数
对于虚函数，编译器执行动态连编（也称动态绑定），即对函数的调用是在运行时确定的。体现多态性 纯虚函数： 1.在父类声明，没有函数体，要求继承父类的子类必须覆盖它 2.带有纯虚函数的类称为 抽象类，不能定义抽象类的 对象 3.每个子类可以根据自己的需要，分别覆盖纯虚函数，从而实现真正意义上的多态性 4.格式： virtual void showInfo()=0;
10.5 多重继承
class c-->class b-->class a
类c继承了类b中的所以成员，包括b从a继承所得的成员。
多继承：一个子类具有2个或多个直接父类，称为多继承
例子：
class DateTime:public Date,public Time//先继承Date类，后继承Time类
{
..........
}
10.6 类模板
1.类模板用于创建类的类和抽象数据类型，使得程序员可以创建一般形式的类，而不必要编写处理不同数据类型的类。 2.类模板的定义和使用必须在同一个文字中，通常为头文件。
第十一章 异常处理
异常是在程序执行期间的突发性事件，与错误不同，错误可通过编译系统处理。
抛出异常：
float div(int numer,int div)
{
if(div==0)
throw "ERROR:divide by zero.\n";
else
return float(numer/div);
}
处理异常：
try{
//可能会出现异常的代码
}
catch(exception param1)
{//处理异常类型1的代码}
catch(exception param2)
{//处理异常类型2的代码}
//异常处理结束后，继续执行的代码
异常处理失败的原因：
1.try语句块中实际产生的异常，与catch语句圆括号指定要捕捉的异常 类型不匹配
2.try语句块的范围太小，在try语句之前就已经产生了异常，那么后面的try语句块将不再执行
本文知识通过观看中国大学MOOC总结而来。
标签：语句,语言,int,函数,定义,C++,char,指针 From： https://www.cnblogs.com/swbna/p/17101083.html