C++基础知识

#include <> 是用系统设定的目录为起点查找头文件，#include " "是先以当前文件所在目录为起点查找，再以系统设定查找。

字节数对应：char 1，short 2，int 4，long 4，float 4，double 8。
特殊标记：3.7f代表单精度，5u代表无符号。

输入/输出缓冲区：printf（）是放入输出缓冲区，若要显示在屏幕上要加/n或程序结束或缓冲区满或fflush（stdout）。

条件编译： 
#ifndef YI   
#define YI  
头文件  
#else  
#endif
	
static修饰全局变量时不可在其他文件中使用，但是生命周期不变，修饰局部变量时作用域不变，生命周期变长，extern可把作用域扩到其他文件。

数据对齐：一个数据的存储起始地址只能是自身大小的整数倍。
数据补齐：结构体中有多个不同类型的变量时，结构图大小必须为最大的那个变量的整数倍。
联合体：所有成员变量的地址一样，多个成员变量共用一个起始地址。

函数名可代表函数地址，int（*p）（int，int）= NULL 代表函数指针 。
malloc()、free()是在堆区操作内存，一直不释放就会导致内存泄漏。
	
文本文件1024就是31H，30H，32H，34H，二进制文件1024就是1024的补码。
	
二级指针就是指针数组，但不是二维数组，二维数组可用数组指针表示。
如char *argv[]和char **argv时，argv[num] 和*(argv+num)都可用s%打印，如：
int b[8][8] 
int (*a)[8] = b 
b[i][j] 就是 *(*(a+i)+j)
	
const修饰时，在 * 前代表值不变 ，在 * 后代表指针不变。
引用：int a=2012，int&b=a。

小端指数据高位在内存高位，大端则相反。

重载函数：char c，bar（c），void bar（const char c），void bar（int c），不可根据返回值形成重载，重载的原理是编译时换名了。
extern "c"的作用是c编译器不会换名而cpp编译器换了名，导致c编译器找不到相应函数，哑元 （int，int），第二个int不实际用，只起重载作用。
	
typedef a b  b为a别名。
	
一般引用只可引左值，常引用左右值都行，也叫万能引用。

class B（const B&that）：m_a(that.m_A)或m_A(100)或{m_a=that.m_a}的解释：
分别调用A的拷贝构造函数，有参构造，无参构造+拷贝复制构造，调用时对基本类型无影响，对类类型调用其相应构造函数。

引用型返回值：如内部定义返回值为static int num，int res=fun（），
那么res是num或者fun（）的别名，而普通的返回值会先赋值给将亡右值，将亡右值再赋值给上一层。
对于int i = int（c），c还是c，会有个临时变量保存了c转换后的值，再赋给了i。
	
const int a=10和const volatile int a=10区别：
const会以为a不变了，取a的值会从寄存器取，但万一内存的a变了，取寄存器就有问题。
	
explicit修饰构造函数：如Integer i；i=100；i=Integer（100）可以；i=100不行。

若未定义任何构造函数，会自动生成无参构造函数，对基本类型不初始化，对类类型调用其无参构造函数，还应完成函数体内的任务。
	
Student(const Student& that) ：调用拷贝构造函数，若未定义就用自动生成的，对基本类型直接复制，对类类型调用其拷贝构造函数。

Counter& add（void）{++ m_data ; return *this;}

内联函数inline，编译时会把此函数在调用点上内联地展开，适合对多次调用的简单函数。

析构函数：Integer（int data）：m_data(new int(data)){}，~Integer(void){delete m_data;m_data=NULL;};
会调用自动生成的析构函数，对基本类型不处理，对类类型调用相应析构函数，有内存泄漏风险，需要重写覆盖。

析构顺序是：先构造的，后析构 ，若类A包含类B ，调用B构再调用A构 ，先调用A析再调用B析，
析构的调用的机：A a在栈区，栈区完了，比如遇到 }了 或 A* pa=new A，delete pa时。
	
常函数：bool same（const S& rhs）const，不可在此函数修改成员变量的值，除非是mutable修饰的，常对象只可调常函数。

公有成员：类内部和外部均可访问，私有成员：只有类内部可访问，protected成员：类和子类能访问，基类的private成员在子类存在但不可直接访问，但可通过继承过来的proteced和public成员函数来访问。

继承方式：
基类中      公有继承            保护继承           私有继承
公有        公                    保               私 
保护        保                    保               私
私有        私                    私               私

向上造型 ：指向子类对象的基类指针或引用，向下造型（不安全）。
	
深拷贝和浅拷贝：int* a，拷贝后指向不同地址，但值一样，浅拷贝可能会被两次析构，即double free。

运算符重载：String& operator=（const String& that）{m_str=that.m_str；return *this；} ，b=a即是b.operator=（a），调用拷贝赋值构造函数。
	
静态成员变量只能在类外部初始化，如：int A :: s_data=100；即使你不定义对象，也分配了内存的，但其访问仍受public、private这种限制，
静态成员函数只能访问静态成员变量的原因：此函数没有指向具体对象的指针。
	
a++为右值，返回拷贝之前的副本；++a为左值，operator+（）和A.operator++(void)分别是前++ 和void哑元的后++，也可定义个全局函数operator++（A，哑元）并在A中声明为它的友元函数，使其可访问A的成员，用friend关键字。
如：
friend ostream& operator<<(ostream& os, const RIGHT& right)
{
	os<<right.a<<right.b<<endl; return os;
}
int a; cout<<a; operator<<(cout，a);

单例模式：一个类只允许一个对象，需要私有化构造函数，在类内部是class A{static A a；}，会提供静态成员函数来访问此对象，分为饿汉式和懒汉式。
	
钻石继承问题：可能会导致两个int a的成员变量，解决办法，让两个父亲都虚继承，virtual继承爷爷。
	
多态：基类virtual void draw（）虚函数，子类对应函数将其覆盖，出现时机是指向子类对象的基类指针或引用调用时，纯虚函数virtual void draw（）=0；抽象类为包含纯虚函数的类，此类不可实例化对象，纯抽象类全是纯虚函数。

析构函数必须为虚函数：本来删子类，实际删了基类，会内存泄漏，可在基类的析构函数前加virtual。
	
强转：
static_cast：double b; int a=static_cast<int>(b);（编译时）；
dynamic_cast：多用于多态继承关系的父子类指针和引用之间转换 （运行时）；
const_cast：去常；
reinterpret_cast：很强势的转换；

异常处理：
try{......;throw -1}；
catch（int a）{cout<<xxx} 
以上代码只能捕获int的异常，如未被捕获会被系统捕获，导致进程终止，throw后会直接找到当前函数的 } 并跳出去，
如果有多层函数就一直找到 } 并跳出去，直至被catch，遇到  }时，当前函数的栈空间会被释放。

C++自带异常类：
class exception{virtual const char * what（）const；}，
可以自定义它的子类并覆盖what函数，catch（exception& ex）{ cout<<ex.what（）}，
若不覆盖的话，也不用写throw，出了问题会自动抛excepion的子异常类，自动根据异常问题打印相应what，覆盖后得自己写throw函数抛出子类，就可以按照自定义的内容进行输出，
内部原理就是里面包含了一个向上造型和虚函数覆盖的操作

十大排序：冒泡，选择排序（每次遍历一遍，找到最大的数，与当前次最右边那个数交换），
插入排序：假设每一轮前面的数已经排好，
选择排序：O（nlogn）
7 12 15 21 3 8 14
12 15 21 3 8 14 
15 21 3 8 14  
14 21 3 8
21 3 14
14 3 
14
14 
到了合适的位置，左右两个部分又递归用此方式。