一 C/C++
（1）构造函数可以是内联函数。
一般情况下，构造函数比较小的情况下，不管你是否指定其为内联函数，C++编译器会自动将其置为内联，如果函数太大，你即使将其指定为内联函数系统也会不理的。因为这会使程序过大。
（2）函数重载：
两个或两个以上的函数，具有相同的函数名，但是形参的个数或者类型不同，编译器根据实参和形参的类型及个数进行最佳匹配，自动确定调用哪个函数，这就是函数的重载。
（3）new和delete不一定要成对出现。
非内置类型一般带有析构函数，会自动释放
如果有下列结构
class T {
T(...);
~T();
};
func()
{
T *test = new T(...)
....
} // 在这里不用手工delete,系统会在{...} 结构末尾施放new
（4）i++，++i
int i = 5;
int j = (i++)+(i++)+(i++);
i = 5;
int k = (++i)+(++i)+(++i);
printf( "j: %d, k:%d\r\n", j,k );
不同的编译器答案有三种：21，22,24.原因在：http://topic.csdn.net/u/20100914/20/76e83d32-6c97-4e13-b997-a1d7229b22da.html
这个跟不同的系统不同的编译器有关系
也就是说跟你的程序的运行环境有关系..
(i++)+(i++)+(i++);拿这个表达式来说。假定i=5
可能有的人（环境）理解为我要先将三个i++弄完，然后再将三个数相加
这样就是8+8+8..（这样还是有依据的括号的优先级是最高的）
可是有的他就不着么算了，他是5+6+7。
后者是未定义行为，因为表达式括号并不是序列点。标准规定i++的后增副作用应该在序列点之前完成，而这里的序列点是整个表达式完成并返回结果。而在这之前2次以上读取变量并同时修改变量的内容的话，其行为就是未定义的了。(i++)+(i++)这个到底是什么效果需要由编译器自己决定，它只要符合规定，怎么计算顺序都是对的。
（5）变量的默认初始化
指导原则：指针尽量初始化为null；局部变量都初始化。
如果是全局变量，所有的全局变量都赋零，字符变量都赋NULL即0.指针变量也是NULL。即全部变量都自动初始化了。
如果是局部变量，所有的变量都不初始化，因此为随机数。如果不赋值就使用，很危险。需要先初始化再使用。
char *str; // 指针str 的指向不为NULL ，而是不确定的空间，很危险。
(6）类中的const
就是说这个类是错误的
class Stock
{
const int size = 30;
}
只有定义，并没有实例化它，也就没有空间给它
如果你在它里面赋值了一个值给它的成员
那么就需要分配空间
显然，这两者是矛盾的
因此，不允许在类里面定义常量
解决：
1 class A{static const intsize=9}；
2class A{ A() {const intsize=9};}
注意：非const的static只能在外部定义。
（7）C++函数中那些不可以被声明为虚函数
常见的不不能声明为虚函数的有：普通函数（非成员函数）；静态成员函数；内联成员函数；构造函数；友元函数。
inline是编译时展开，必须有实体；
static属于class自己的，也必须有实体；
virtual函数基于vtable（内存空间），constructor函数如果是virtual的，调用时也需要根据vtable寻找，但是constructor是virtual的情况下是找不到的，因为constructor自己本身都不存在了，创建不到class的实例，没有实例，class的成员（除了public static/protectedstaticfor friend class/functions，其余无论是否virtual）都不能被访问了。
友元函数不能被继承。
(8)一个可用的类一般应该包括一般构造函数，拷贝构造函数，赋值函数，析构函数
当需要深拷贝时，则需要拷贝构造函数和赋值函数。
拷贝构造函数，赋值构造函数的区别在于：复制构造函数是去完成对未初始化的存储区的初始化，而赋值操作符则是处理一个已经存在的对象。对一个对象赋值，当它一次出现时，它将调用复制构造函数，以后每次出现，都调用赋值操作符。
例如，
定义对象a，并用另一个对象b对a进行初始化时，
若没有复制构造函数时，那么编译器会自动生成一个
T b(1);//假设对象b已经初始化
T a(b);//初试化阶段，调用复制构造函数
T c = b;//虽然使用了“=”，但是初试化阶段，仍调用复制构造函数
T d；
d = a; //因为对象c已经定义，所以此处调用赋值操作符重载函数。如果没有编译器会自动生成一个
（9）malloc和new的区别
1,malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。
2,对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。
new可以认为是malloc加构造函数的执行。new出来的指针是直接带类型信息的。而malloc返回的都是void指针。
（10）RTTI(运行时类型信息)机制--RuntimeType Information”
运行时类型信息(RTTI)是一种机制，它允许在程序运行时确定一个对象的类型。
出于对清晰度透明性的考虑，关于RTTI的讨论几乎全部限于指针。然而，所进行的讨论也应用于引用。 RTTI中包含三种主要的C++语言的元素：
1.dynamic_cast：用于多态类型之间转换的操作符
2.typeid：用于表示一个对象的确切类型的操作符
3.type_info：用于保存typeid操作符返回的关于类型信息的类。
1 base *pg=new base;
derived * pm=dynameic_cast<derived*>(pg);
这提出了这样的问题:指针pg的类型是否可被安全地转换为Superb *? 如果可以，操作符将返回对象的地址，否则返回一个空指针。
2. typeid 操作符和type_info 类
typeid操作符使得能够确定两个对象是否为同种类型。它与sizeof有些相像，可以接受两种参数:
(1) 类名。
(2) 结果为对象的表达式。
ypeid操作符返回一个对type_info对象的引用，
例如，如果pg指向的是一个Magnificent对象，则表达式:
typeid(Magnificent) ==typeid(*pg)
结果将为bool值true，否则为false。
（11）原子操作有哪些？
是的：立即数赋值m=5;m=5+6;
不是的：m=m+5,m++
（12）纯虚函数
不同于虚函数，后面必须添加“=0”：virtual void lock(void)=0;
除非在派生类中完全实现基类中所有的的纯虚函数，否则，派生类也变成了抽象类，不能实例化对象。
（13）异常
throw ,try catch,finally。
finally在程序结束前一定会执行，除了使用system(exit 0)
（14）宏和内联函数
1 宏替换发生在预处理阶段，内联函数在编译阶段展开。
2宏参数替换不做类型检查，容易产生二义性或者错误；函数的参数则会先求值。
3 宏不能访问对象的私有成员，而函数更加强大，实现的功能更多。
（15）sizeof（string）
是32.string是一个类。不同的库实现不同。现在一般是32.
（16）hash碰撞的处理方法
1．close hashing-- 开放寻址法；Hi=(H(key) + di) MOD m,i=1,2,…，k(k<=m-1)，其中H(key)为散列函数，m为散列表长，di为增量序列，可有下列三种取法：
1)． di=1,2,3,…，m-1，称线性探测再散列； 2)． di=1^2,(-1)^2,2^2,(-2)^2,(3)^2,…，±(k)^2,(k<=m/2)称二次探测再散列； 3)． di=伪随机数序列，称伪随机探测再散列。 2．open hashing-链地址法(拉链法) 3． 再散列法：Hi=RHi(key),i=1,2,…，k
RHi均是不同的散列函数，即在同义词产生地址冲突时计算另一个散列函数地址，直到冲突不再发生，这种方法不易产生“聚集”，但增加了计算时间。
4． 建立一个公共溢出区
（17）错误和异常的区别
很一般的来讲，错误在编译的时候就可以发现，我们还可以用assert来检测。
异常是在执行过程中发生的意外，由潜在的错误机率导致（错误是由100%的错误机率导致。）如果我们能够很好的使用throw,catch，许多风险是能够避免的。
异常有时并不是由于你的程序的问题引起的，如用new 申请一个内存块失败时，数据库操作失败时，就会产生一个异常，异常往往是程序的执行过程中不可预料的。如果不对产生的异常进行处理，程序往往崩溃，会使软件显得很脆弱。
错误而言，不管是语法错误，逻辑错误都是可以通过检查发现的。
二 数据库
1 范式
大部分数据库从业人员都知道关系数据库有三个基本的范式，即：第一范式，第二范式，第三范式。当然也有牛人知道BC范式，第四范式，第五范式，第六范式，甚至还有个DK范式。本人对数据库的范式概念也是一知半解的，想想有些可笑，搞数据库的竟然不了解关系数据库的基础——范式。这不最近查阅了不少资料，今天把这些东东总结一下。
范式：英文名称是Normal Form，它是英国人E.F.Codd（关系数据库的老祖宗）在上个世纪70年代提出关系数据库模型后总结出来的，范式是关系数据库理论的基础，也是我们在设计数据库结构过程中所要遵循的规则和指导方法。目前有迹可寻的共有8种范式，依次是：1NF，2NF，3NF，BCNF，4NF，5NF，DKNF，6NF。通常所用到的只是前三个范式，即：第一范式（1NF），第二范式（2NF），第三范式（3NF）。
下面就简单介绍下这三个范式。
◆ 第一范式（1NF）：
强调的是列的原子性，即列不能够再分成其他几列。
考虑这样一个表：【联系人】（姓名，性别，电话）
如果在实际场景中，一个联系人有家庭电话和公司电话，那么这种表结构设计就没有达到 1NF。要符合 1NF 我们只需把列（电话）拆分，
即：【联系人】（姓名，性别，家庭电话，公司电话）。1NF 很好辨别，但是 2NF 和 3NF 就容易搞混淆。
◆ 第二范式（2NF）：
首先是 1NF，另外包含两部分内容，一是表必须有一个主键；二是没有包含在主键中的列必须完全依赖于主键，而不能只依赖于主键的一部分。
考虑一个订单明细表：
【OrderDetail】（OrderID，ProductID，UnitPrice，Discount，Quantity，ProductName）。
因为我们知道在一个订单中可以订购多种产品，所以单单一个 OrderID 是不足以成为主键的，主键应该是（OrderID，ProductID）。
显而易见 Discount（折扣），Quantity（数量）完全依赖（取决）于主键（OderID，ProductID），而 UnitPrice，ProductName 只依赖于 ProductID。所以 OrderDetail 表不符合 2NF。不符合 2NF 的设计容易产生冗余数据。
可以把【OrderDetail】表拆分为【OrderDetail】（OrderID，ProductID，Discount，Quantity）和【Product】（ProductID，UnitPrice，ProductName）来消除原订单表中UnitPrice，ProductName多次重复的情况。
◆ 第三范式（3NF）：首先是 2NF，另外非主键列必须直接依赖于主键，不能存在传递依赖。即不能存在：非主键列A 依赖于非主键列 B，非主键列 B 依赖于主键的情况。
考虑一个订单表【Order】（OrderID，OrderDate，CustomerID，CustomerName，CustomerAddr，CustomerCity）主键是（OrderID）。
其中 OrderDate，CustomerID，CustomerName，CustomerAddr，CustomerCity 等非主键列都完全依赖于主键（OrderID），所以符合 2NF。不过问题是 CustomerName，CustomerAddr，CustomerCity 直接依赖的是 CustomerID（非主键列），而不是直接依赖于主键，它是通过传递才依赖于主键，所以不符合3NF。
通过拆分【Order】为【Order】（OrderID，OrderDate，CustomerID）和【Customer】（CustomerID，CustomerName，CustomerAddr，CustomerCity）从而达到 3NF。
第二范式（2NF）和第三范式（3NF）的概念很容易混淆，区分它们的关键点在于，2NF：非主键列是否完全依赖于主键，还是依赖于主键的一部分；3NF：非主键列是直接依赖于主键，还是直接依赖于非主键列。
三 其它
（1）UML类图
属性和操作之前可附加一个可见性修饰符。加号（+）表示具有公共可见性。减号（-）表示私有可见性。#号表示受保护的可见性。省略这些修饰符表示具有package（包）级别的可见性。如果属性或操作具有下划线，表明它是静态的。
类图中斜线表示纯虚函数和抽象类。
类名BankAccount和withdrawal操作使用斜体。这表示，BankAccount 类是一个抽象类，而withdrawal方法是抽象的操作。换句话说，BankAccount 类使用withdrawal规定抽象操作，并且CheckingAccount 和 SavingsAccount 两个子类都分别地执行它们各自版本的操作。
（2）big endian 和 little endian
大尾端使我们理解的正常顺序，小尾端相反。包括字节序和比特序。
一字节序
power pc采用bigendian,x86采用little endian
比如数字0x12345678在两种不同字节序CPU中的存储顺序如下所示：
Big Endian
低地址高地址
----------------------------------------->
| 12 | 34 | 56 | 78 |
Little Endian
低地址高地址
| 78 | 56 | 34 | 12 |
C/C++语言编写的程序里数据存储顺序是跟编译平台所在的CPU相关的，而JAVA编写的程序则唯一采用big endian方式来存储数据。
2 比特序
CPU存储一个字节的数据时其字节内的8个比特之间的顺序是否也有bigendian和little endian之分？或者说是否有比特序的不同？实际上，这个比特序是同样存在的。下面以数字0xB4（10110100）用图加以说明。
Big Endian
---------------------------------------------->
| 1 | 0 | 1 | 1 | 0 | 1 | 0 |0
Little Endian
| 0 | 0 | 1 | 0 | 1 | 1 | 0 |1 |