C/C++数字范围（32位系统）
bool： ~ // 1 字节
char // 1 字节
short： - ~ // 2 字节
int： - ～ // 4 字节
unsigned： ～ // 4 字节
size_t： ~ // 4 字节
long： - ～ // 4 字节，Linux64位下的long占 8 字节！！！
unsigned long： ～ // 4 字节
long long： - ～ // 8 字节
unsigned long long： ～ // 8 字节
__int64： - ～ // 8 字节
unsigned __int64： ～ // 8 字节
float： 1.17549- ~ 3.40282e+038 // 4 字节
double： 2.22507e-308 ~ 1.79769e+308 // 8 字节
long double： 3.3621e-4932 ~ 1.18973e+4932 // 12 字节
1. 整数除法
实现整数除法，不使用 * 、/ 、% 三个运算符。若结果越界，返回 INT_MAX。
原理：
假设计算 15 除以 3，15 是 dividend 被除数，3 是 divisor 除数。
“除法”需要知道 dividend 能够减去 divisor 多少次而不使 dividend 为负。
开始计算叭~将结果记录在 result 中（初始化为0）。
首先 15 - 3 = 12 > 0；尝试减去更大的数，把 3 左移一位 (0011)2 -> (0110)2 得到 6，15 - 6 > 0；再左移一位得到 12，15 - 12 > 0；继续左移一位得到24，15 - 24 < 0。这样我们知道 dividend (15) 最多能减 12。12 是由 divisor (3) 左移 2 次得到，左移 2 次相等于 × 4，4 即为 (0001)2 左移 2 次得到，因此将 4 加到 result 中。
接下来 dividend 15 - 12 后剩余 3，重复上述计算，将 1 加到 result 中得到最终答案 5。
被除数和除数若含有负数，则统一化为正数按上述算法计算后，再判断 result 符号即可。
C++实现：
int divide(int dividend, int divisor) {
// 整数除法，因此只有当 dividend == -231，divisor == -1 时结果才会越界
if (!divisor || (dividend == INT_MIN && divisor == -))
return INT_MAX;
/* ！使用 异或 操作符判断符号值得学习！ */
int sign = ((dividend < ) ^ (divisor < )) ? - : ;
// dividend == -231时，取绝对值后仍赋值给 int 则会越界，因此存储在 long long
long long dvd = labs(dividend);
long long dvs = labs(divisor);
int res = ;
while (dvd >= dvs) {
long long temp = dvs, multiple = ;
while (dvd >= (temp << )) {
temp <<= ;
multiple <<= ;
}
dvd -= temp;
res += multiple;
}
return sign == ? res : -res;
}
2. 乘方
实现 Pow(x, n)。
若用类似于求 n 的阶乘的递归方法计算，时间复杂度为 O(n)。
但考虑到 n 个 x 相乘式子的对称关系，可以采用二分法，xn = xn/2 * xn/2 * xn%2，时间复杂度为 O(logn)。
C++实现：
double myPow(double x, int n) {
if (!n)
return ;
if (n < ) {
n = -n;
x = / x;
}
return (n % == ) ? myPow(x * x, n / ) : x * myPow(x * x, n / );
}
但这段代码并没有做边界条件判断，n 取值 INT_MIN 时，-n 并不是 INT_MAX
需要在 n < 0 的条件下增加判断
if (n == INT_MIN)
return / (x * myPow(x, INT_MAX));
或者改为
if (n < ) {
return / (x * myPow(x, -(n + )));
}
最后可以用位运算加快执行速度
double myPow(double x, int n) {
if (!n)
return ;
if (n < ) {
return / (x * myPow(x, ~n));
}
return ((n & ) == ) ? myPow(x * x, n >> ) : x * myPow(x * x, n >> );
}
用 ~n 代替 -(n + 1)。
e.g. n = 15，求 ~n。
n的源码 = 00000000 00000000 00000000 00001111
正数的补码是自身（计算机以补码存储数据）
n的补码 = 00000000 00000000 00000000 00001111
按位取反（包括符号位）
~n的补码 = 11111111 11111111 11111111 11110000
负数的补码是源码取反加1，源码也是补码取反加1（符号位不变）
~n的源码 = 10000000 00000000 00000000 00010000
求得 ~n 为 -16。同理 n = -15 时，求得 ~n = 14。
if ((n & 1) == 0) 判断奇偶效率更高，虽然编译器都会将 n % 2 优化为位运算。
但值得注意的是，& 作为“按位与”而不是“取地址符”时，其优先级低于 == 和 !=，因此如果不写括号的话 (n & 1 == 0) 为永 false 的。
编写更加易读的代码比起过多考虑细枝末节的效率问题更加重要！若想高效，建议改进算法，而不是改进写法！
递归虽然很好理解，但会占用递归栈的空间，因此用迭代的方法更加高效。
考虑 n 的二进制表示，例如 n = (1000 1011)2，那么xn = x1+2+8+128 = x1 * x2 * x8 * x128。
因此可以循环 n 的每一位，如果该位置是 1，就把 xi 乘到结果中去，时间复杂度为 O(logn)。
任何数与 1 相与结果不是 0 就是 1，一般用 n & 1 判断 n 的奇偶，这里则是不断把 n 右移一位，判断 n 的最后一位是不是 1，如果是 1，就把 xi 乘到结果中去。
double myPow(double x, int n) {
if (!n)
return ;
if (n < ) {
return / (x * myPow(x, ~n));
}
double result = ;
for(; n > ; x *= x, n >>= ) {
if (n & > )
result *= x;
}
return result;
}
3.