数组
一维数组
声明
格式：存储在每个元素中的值的类型 + 数组名 + 数组中的元素数（值>=1的常量表达式）
如：int a[10];
例题：定义数组a的引用。 int a[6] = {0,2,4,6,8,10};
答：int (&p) [6] = a; //p是数组a的引用，数组引用可用于函数实参传递
初始化
(1) int a[6] = {0,2,4,6,8,10}; //基本初始化
(2) int x[4] = {0}; //x的值为｛0,0,0,0｝，若只初始化部分元素，其后的元素会被初始化为0
int y[4] = {1}; //y的值为｛1,0,0,0｝
(3) int *a = new int[n]; //当数组大小未知时的 动态声明一维数组；其中n为常量，为初始数组大小
delete []a; //当数组使用完毕，需要释放空间；
字符常量&字符串常量（C语言）
字符常量：用单引号括起来的单个字符，比如：‘A’；
字符串常量：用双引号括起来的字符序列，比如："A"，其表示字母A和空字符(null)两个字符.
字符数组
字符数组既可以用一组花括号括起来，逗号隔开的字符常量进行初始化，也可以用一个常量字符串（末尾有空字符）进行初始化。
方式1：char ca1[] = {'C', '+', '+'}; //末尾没有null字符，3个元素
方式2：char ca2[] = {'C', '+', '+', '\0'}; //末尾显示地添加null字符，4个元素
方式3：char ca3[] = "C++"; //末尾自动添加null字符，4个元素
附：C风格字符串包括字符串常量和末尾添加了'\0'的字符数组，即ca3和ca2都是C风格字符串；
'\0'表示null结束符，在处理C风格字符串的标准库函数时，参数必须以结束符null结束。
二维数组
声明&初始化
//按行初始化
int ia[3][4] = {
{0,1,2,3},
{4,5,6,7},
{8,9,10,11}
};
//顺序初始化
int ia[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};
//初始化每行第一个元素,其余元素为0
int ia[3][4] = {{0},{4},{8}};
//初始化第一行元素，其余元素为0
int ia[3][4] = {0,1,2,3};
//附：如果对二维数组的所有元素都赋值，则第一维（行数）可以省略
int ia[][3] = {1,2,3,4,5,6};
相当于：
int ia[2][3] = {1,2,3,4,5,6};
动态声明
//声明,a[m][n]
int **a = new int* [m];
for(int i=0;i<m;i++){
a[i] = new int [n]; }
//释放（动态声明的数组，使用后需要释放内存）
for(int i=0;i<m;i++){
delete []a[i];
delete []a;
行优先存储&列优先存储
在C/C++中，二维数组按照行优先顺序连续存储
行优先存储：在内存中，先将二维数组的第一行按顺序存储，接着是第二行、第三行......
列优先存储：在内存中，先将二维数组的第一列按顺序存储，接着是第二列、第三列......
数组指针&指针数组&数组名的指针操作
指针运算
算术运算：指针加上一个整数的结果是另一个指针；
关系运算：当指向同一个数组中的元素时，可以进行<,<=,>,>=运算
指针数组&数组指针
指针数组：一个数组里面装着指针，即指针数组是一个数组，定义为： int *a[10];
数组指针：是一个指向数组的指针，实际还是指针，只是指向整个数组，定义为： int (*p)[10];
附：[]的优先级高于*；指针数组和数组指针主要看后面两个字是什么；
举例1：
//二维数组的数组名是一个数组指针 int a[4][10]; int (*p)[10]; p = a; //a的类型是int (*)[10]
说明：p可以被替换为a; a是常量，不能进行赋值操作；int（*p)[10]中的10表示指针指向的数组有10个元素;
举例2：
int a[10]; int (*p)[10]=&a; //a的类型是int *; &a的类型int (*)[10] int *q = a;
说明：p是指向有10个元素整型数组的指针，*p的大小是40个字节，p+1跳过40个字节；q是指向整型的指针，*q的大小是4个字节，q+1跳过4个字节。
数组名的指针操作
//1.在表达式中使用数组名时，该名字会自动转换成指向数组首元素（第0元素）的指针
int ia[] = {0,2,4,6,8};
int *ip = ia; //指针ip指向了数组ia的首元素
//2.如果希望指针指向数组中另一个元素，这可以使用下标操作给某个元素定位，然后用取地址操作符&获取该元素的存储地址
ip = &ia[4]; //ip指向了数组ia的末尾元素8
//3.在指向数组某个元素的指针上加上（减去）一个整型数值，可以计算出指向数组另一元素的指针值
ip = ia； //ip指向ia[0] int *ip2 = ip + 4; //ip2指向ia[4]
//4.如果要修改第4个元素为9，则有下面集中方法
ia[4] = 9; //或 *(ia+4) = 9; //或 ip[4] = 9; //或 *(ip+4) = 9;
附1：对于int a[10];
（1）&a[0] 为首元素的地址，即指向首元素的指针，&a[0]等价于a；
（2）&a为指向数组的指针，与a的类型不同（a的类型为int (*)[10]），但是指向的单元相同;
（3）数组的首地址是常量，不可以进行赋值操作；
附2:当数组作为函数实参传递时，传递给函数的是数组首元素的地址；将数组某一个元素的地址当作实参时，传递的是此元素的地址；
高维数组中的指针运算
以二维数组 int a[4][5]为例：
&a：类型为int(*)[4][5],二维数组的首地址；
a+i：类型为int(*)[5],指向数组a[i]第0个元素a[i][0]的指针；
*(a+i)=a[i]：类型为int*；
*(*(a+i)+j)=a[i][j]，类型为int；
数组的应用
一维数组：线性表的线性存储；哈希表
二维数组：对称矩阵的压缩；图的邻接矩阵；
字符串
字符串&子串&子序列
字符串：由零个或多个字符组成的有限串行；
子串：字符串中任意个连续的字符组成的子序列，其中空串是任意串的子串，任意串是其自身的子串；
子序列：不要求字符连续，但顺序与在主串中一致；
C风格字符串
char ca2[] = {'C', '+', '+', '\0'}; //末尾显示地添加null字符，4个元素
char ca3[] = "C++"; //末尾自动添加null字符，4个元素
C风格字符串包括字符串常量和末尾添加了'\0'的字符数组，即ca3和ca2都是C风格字符串；
'\0'表示null结束符，在处理C风格字符串的标准库函数时，参数必须以结束符null结束。
标准库提供的字符串处理函数
strlen&strcmp&strcat&strcpy&strncat&strncpy
附：strlen(s)计算不为'\0'字符数组元素个数，以'\0'为结束标志，不包含'\0';
memcpy&memset
*memcpy(*dest,*src,n)：从源src所指的内存地址的起始位置拷贝n个字节到目标dest所指的内存地址的起始位置，返回指向dest的指针；
*memset(*s,int ch,n)：将s中前n个字节用ch替换并返回s，作用是在一段内存中填充某个给定的值；
结构体&共用体&枚举
结构体struct
struct 结构体类型名｛
类型名1 成员名1；
类型名2 成员名2；
...
类型名n 成员名n;
｝
注：结构体类型只说明该类型的组成情况，没有分配内存空间，只有定义属于结构体类型的变量时，系统才会分配空间给该变量；
（1）结构体类型定义中不允许对结构体本身的递归定义，但可以使用指针指向本类型。如
struct person｛ 类型名1 成员名1； ... struct person *per;//指向本类型的指针 ｝
（2）结构体定义中可以包含另外的结构体，结构体是可以嵌套的；
（3）结构体变量可以在定义时进行初始化赋值；
struct person｛
char name[20];
char sex;
}boy1={"zhangbing",'M'};
共用体union
union 共用体名｛
数据类型 成员名；
数据类型 成员名；
...
数据类型 成员名;
｝变量名；
共用体与结构体的区别：
（1）共同体只存放了一个被选中的成员，而结构体的所有成员都存在。
（2） 对于共同体的不同成员赋值，将会对其他成员重写，原来的成员值就不存在了，而对于结构体的不同成员赋值是互不影响的。
大端存储格式&小端存储格式：
（1）共用体和结构体的存放顺序是所有成员都从低地址开始存放。
（2）小端存储格式：字数据的低字节存储在低地址中。
（3）大端存储格式：字数据的高字节存储在低地址中。
枚举enum
enum 枚举类型名｛枚举常量1[=整型常数],枚举常量2[=整型常数],......｝[变量名列表]
如：
enum spectrum{red,orange,yellow,green,blue};
sizeof
注：sizeof计算长度将'\0'计算在内，strlen以'\0'为结束标志，不将'\0'计算在内；
struct空间计算（对齐）
1）整体空间是占用空间最大的成员类型所占字节数的整数倍；
2）数据对齐原则：内存按照结构体成员的先后顺序排列，当排到该成员变量时，前面已经摆放的空间大小是该成员类型大小的整数倍，不够则补齐，依次向后类推；
上述语句1输出为24，语句2输出为16；
union空间计算
1）取占用内存最多的成员空间作为自己的空间；
2）但也要考虑对齐问题；
上述联合体的空间大小是12，数组b占用9个字节，考虑对齐，需要是4(int占用空间)整数倍，补齐为12；
枚举空间计算
enum只是定义了一个常量集合，里面没有元素，枚举类型当作int存储，所以枚举类型的sizeof值都为4；
运算符及其优先级
1）自增、自减、负号运算符的结合方向是从右向左，k=-i++等效于k=-(i++);但是注意“先用后变”，所以等于 k=-i,i++;
2）逻辑操作符（||，&&）先计算左操作数，再计算右操作数，只有在仅靠做操作数无法确定值时，才去求解右操作数；
3）位运算符：左移低位补0，右移（int高位补符号位，unsigned int高位补0）；
优先级：~>左移右移>与、或、非
4）运算时，较小的类型会被转换为较大的类型
5）移位运算>关系>与，或，异或>逻辑运算
C处理器&作用域&static&const&内存管理
C处理器
1）宏定义与宏替换：#define 标识符 字符串
2）文件包含： #include <>
3）条件编译：#if/ifdef/ifndef #elif #else #endif
全局变量
使用extern关键字引用一个已经定义过的全局变量。
static
1）隐藏：未加static前缀的全局变量和函数都具有全局可见性，其他源文件也能访问；
2）默认初始化为0；
3）保持局部变量内容的持久：静态局部变量始终存在着，生存期为整个源程序，只进行一次初始化且具有“记忆性”；
const
声明常量
内存管理与释放
1）栈（stack）：由编译器自动分配释放，存放函数的参数值，局部变量的值等，速度快；
2）堆（heap）：由程序员分配释放，若程序员不释放，程序结束时由操作系统回收，分配方式类似于链表，速度慢；
3）程序的局部变量存在于堆栈中，全局变量存在于全局（静态）存储区中，动态申请数据存在于堆中；
4）malloc/free 是C/C++语言标准库函数，new/delete是C++运算符；new自动计算分配空间，malloc手动计算字节数
函数
参数传递
1）形参：出现在函数定义中，整个函数体内可以使用，离开该函数则不能使用；
2）实参：出现在主调函数中，进入被调函数后，实参变量也不能使用；
3）函数调用方式：值传递，指针(地址)传递，引用传递（C++）
4）非引用类型的形参以相应实参的副本初始化，对非引用形参的任何修改仅作用于局部副本，不影响实参本身，对引用形参的任何修改会直接影响实参本身。
5）用*定义指针，用&定义引用；
内联函数
用inline修饰
1）成员函数为内联函数：在类中定义的成员函数全部默认为内联函数，加或不加inline都行；类中声明的成员函数加了inline则为内联函数，没加inline时如果在类外定义了加了inline时，也为内联函数；
2）普通函数为内联函数：普通函数声明或定义前加inline使其成为内联函数；
3）内联扩展可以消除函数调用时的时间开销；
默认参数
1）默认参数只能在函数声明中设定一次，只有无函数声明时，才可以在函数定义中设定；
2）默认参数定义的顺序为从右到左，如果一个参数设定了默认值，则其右边的参数都要有默认值；
3）默认参数调用时，遵循参数调用顺序，自左向右逐个调用；
4）默认值可以是全局变量，全局常量，函数，但不可以是局部变量；
函数重载
1）在一定作用域内，可以有一组相同函数名，不同参数列表的函数，这组函数被称为重载函数；
2）进行函数重载时，要求同名函数在参数个数上不同，或者参数类型上不同；
函数模板与泛型
1）泛型编程：以独立于任何特定类型的方式编写代码，与面向对象编程一样，都依赖于某种形式的多态性；
2）函数模板定义以关键字template开始，模板非类型形参是模板定义内部的常量值；
3）宏定义是在预处理阶段进行代码替换，内联函数是在编译阶段插入代码，宏定义有类型检查，内联函数没有类型检查；
4）类模板
函数的递归
递归的精髓在于能否将原始问题转换为属性相同但规模较小的问题，需要满足1）递归表达式，2）边界条件；
指针与引用
指针
1）指针声明： string *p1,*p2;
2）typedef 类型名 标识符； //typedef没有产生新的数据类型，只是给已存在的类型起一个“别名”；
3）C++提供了一种特殊指针类型void*，可以保存任何类型对象的地址；
4）指向指针的指针：用**表示
5）函数指针：指向函数而非指向对象的指针
6）可以用typedef简化函数指针的定义，cmpFcn是一种指向函数的指针类型的名字；
7）指向函数的指针可用于调用它所指向的函数
引用
1）引用是对象的另一名字，是一个特殊的变量，该变量的内容是绑定在这个引用上面的对象的地址，使用变量时，系统根据地址找到绑定的变量，再进行操作；
2）C++规定一旦定义了引用，就必须把它和另一个变量绑定起来，并且不能修改这个绑定；
3）不能定义引用类型的引用，但是可以定义任何其他类型的引用；
4）引用不能为空，创建时需初始化；
5）sizeof（引用）得到的是所指向的变量的大小，sizeof(指针）得到的是指针本身的大小；
6）当使用&运算符取一个引用地址时，其值为所引用变量的地址，而对指针使用&运算，取的是指针变量的地址；
类
1）访问标号：public、private、protected
2）类对成员的访问有：内部访问（由类中的成员函数对类的成员的访问）；对象访问（在类外部，通过类的对象对类的成员的访问）；
类成员简介
1）成员函数：声明成员函数是必须的，定义成员函数是可选的，每个成员函数都有一个隐形的this
2）构造函数：特殊的成员函数，构造函数和类同名，没有返回类型，一个类可以有多个构造函数，每个构造函数须有与其他构造函数不同数目或类型的形参；
3）析构函数：析构函数可以完成所需资源的回收，作为类构造函数的补充
构造函数与析构函数的调用顺序
1）单继承：派生时，构造函数和析构函数不能继承，需要重新定义，并在构造函数的初始化列表中调用基类的构造函数；
创建派生类对象时，先通过派生类的构造函数调用基类的构造函数，完成基类成员的初始化，再对派生类新增成员进行初始化；
删除派生类对象时，先执行派生类的析构函数，再执行基类的析构函数；
2）多继承：派生类的构造函数初始化列表需要调用各个基类的构造函数；
基类构造函数按照基类构造函数在类派生列表中的出现次序调用；析构函数的顺序依然按照构造函数运行的逆序进行；
3）虚继承：首先调用虚基类的构造函数，调用顺序是此虚基类在当前类派生列表中出现的顺序；
成员函数的重载、覆盖、隐藏
重载（overload）
相同的范围（同一个类中）；相同的函数名字；不同的参数列表；virtual关键字可有可无；
覆盖（override）
在派生类中覆盖基类的同名函数，要求基类函数必须是虚函数，且
1）与基类的虚函数有相同的参数个数；
2）与基类的虚函数有相同的参数类型；
3）与基类的虚函数有相同的返回类型
覆盖的特征：不同的范围（位于派生类和基类）；相同的函数名字；相同的参数；基类函数必须有virtual关键字；
重载和覆盖的区别：
1）覆盖是父类和子类的关系，是垂直关系；重载是同一个类中不同方法之间的关系，是水平关系；
2）覆盖要求参数列表相同；重载要求参数列表不同；
3）覆盖要求返回类型相同，重载不要求；
4）覆盖关系中，调用方法体是根据对象的类型来决定的，重载关系是根据调用时的实参表与形参表去选择方法体的；
隐藏（hide,oversee）
某些情况下，派生类中的函数屏蔽了基类中的同名函数，包括
1）两个函数参数相同，但基类函数不是虚函数；
2）两个函数参数不同，无论基类是否是虚函数，基类函数都会被屏蔽；
面向对象编程
继承
利用已有的数据类型来定义新的数据类型，基类/父类，派生类/子类
1）单继承：从一个基类派生的继承
class <派生类名>:<继承方式> <基类名>{
<派生类新定义成员>
｝
<继承方式>：public（公有基类）；private（私有基类）；protected（保护基类）；
2）多继承：从多个基类派生的继承
class <派生类名>：<继承方式1><基类名1>，<继承方式2><基类名2>，...{
<派生类新定义成员>
｝
public&private&protected
1）公有继承（public）：基类的公有成员和保护成员作为派生类的成员时，他们保持原有的状态，而基类的私有成员仍是私有的，不能被派生类的子类访问；
公有继承时，派生类的对象可以访问基类中的公有成员，派生类的成员函数可以访问基类中的公有成员和保护成员；
2）私有继承（private）：基类的公有成员和保护成员都是作为派生类的私有成员，并且不能被这个派生类的子类访问；
私有继承时，基类的成员只能由直接派生类访问，无法再往下继承；
3）保护继承（protected）：基类的所有公有成员和保护成员都作为派生类的保护成员，并且只能被它的派生类成员函数或友元访问，基类的私有成员仍是私有的；
虚函数多态
“一个接口，多种方法”，比如一个函数名（调用接口）对应着几个不同的函数原型（方法）；
参考资料：
《王道程序员面试宝典》