整数在计算机内以有限字长表示，当超出最值（有限字长）时，需要截断（溢出，求模）操作。

不同字长的整型具有不同的值域，混合运算时，需要类型提升和转换。

1 整形最值

在<limit.h>中有整型的最值（宏定义）。

#define CHAR_BIT      8         /* number of bits in a char */
#define SCHAR_MIN   (-128)      /* minimum signed char value */
#define SCHAR_MAX     127       /* maximum signed char value */
#define UCHAR_MAX     0xff      /* maximum unsigned char value */

#define MB_LEN_MAX    2             /* max. # bytes in multibyte char */
#define SHRT_MIN    (-32768)        /* minimum (signed) short value */
#define SHRT_MAX      32767         /* maximum (signed) short value */
#define USHRT_MAX     0xffff        /* maximum unsigned short value */

#define INT_MIN     (-2147483647 - 1) /* minimum (signed) int value */
#define INT_MAX       2147483647    /* maximum (signed) int value */
#define UINT_MAX      0xffffffff    /* maximum unsigned int value */

#define LONG_MIN    (-2147483647L - 1) /* minimum (signed) long value */
#define LONG_MAX      2147483647L   /* maximum (signed) long value */
#define ULONG_MAX     0xffffffffUL  /* maximum unsigned long value */

demo code:

#include <stdio.h>
int int_min()
{
    return (1<<31);
}

int int_max()
{
    return (1<<31)-1;
}

int uint_max()
{
    return (1<<32)-1;
}

typedef enum typeFlag{MIN,MAX,UMAX}tf_;
template <typename T>
T minmax(T tv,tf_ tf)
{
    switch(tf){
    case MIN:
        return 1<<(sizeof(T)*8-1);  
    case MAX:
        return (1<<(sizeof(T)*8-1))-1;  
    case UMAX:
        return (1<<sizeof(T)*8)-1;
    default:
        break;
    }
}

int main()
{
    printf("char_min: \t\t%d\n",minmax<char>(0,MIN));
    printf("char_max: \t\t%d\n",minmax<char>(0,MAX));
    printf("unsigned char_max: \t%u\n",minmax<unsigned char>(0,UMAX));
    
    printf("short_min: \t\t%d\n",minmax<short>(0,MIN));
    printf("short_max: \t\t%d\n",minmax<short>(0,MAX));
    printf("unsigned short_max: \t%u\n",minmax<unsigned short>(0,UMAX));

    printf("int_min: \t\t%d\n",minmax(0,MIN));
    printf("int_max: \t\t%d\n",minmax(0,MAX));
    printf("unsigned int_max: \t%u\n",minmax(0u,UMAX));

    getchar();
}
/*
char_min:               -128
char_max:               127
unsigned char_max:      255
short_min:              -32768
short_max:              32767
unsigned short_max:     65535
int_min:                -2147483648
int_max:                2147483647
unsigned int_max:       4294967295
*/

2 整型的溢出（上溢和下溢）

2.1 无符号（unsigned）整数加法的溢出

w 位（二进制位）无符号整数 v 在计算机中可以表示的值域为：

考虑两个非负整数x和y，满足，每个数都能表示为 w 位无符号整数。

然而，如果计算它们的和，我们就有一个可能的范围。表示这个和可能需要w+1位，对于有限字长的无符号整数加法，其多出的一位就会截断，也就是溢出或模的运算。

溢出检测：

#include <stdio.h>
bool uadd_ok(unsigned x, unsigned y){
    unsigned sum = x+y;
    return sum>=x; // or return sum >= y;
}
int main()
{
    unsigned int x = (1<<32)-1;
    unsigned int y = 11;
    printf("%u %d %d\n",x+y,uadd_ok(x,y),x+y-(1<<32)); // 10 0 10
    getchar();
}

2.2 有符号（signed)整数（补码）加法的溢出

w 位（二进制位）有符号整数 v 在计算机中可以表示的值域为：

w 位（二进制位）有符号整数x+y的溢出情况：

溢出检测：

#include <stdio.h>
bool tadd_ok(int x, int y){
    int sum = x+y;
    int neg_over = x<0 && y<0 && sum >=0;
    int pos_over = x>=0 && y>=0 && sum <0;
    return !neg_over && !pos_over;
}
int main()
{
    int x = (1<<31)-1;  // int最大值
    int y = 11;
    printf("%d %d %d\n",x+y,tadd_ok(x,y),x+y-(2<<32)); // -2147483638 0 -2147483638
    x = 1<<31;          // int 最小值
    y = -11;
    printf("%d %d %d\n",x+y,tadd_ok(x,y),x+y+(2<<32)); // 2147483637 0 2147483637
    getchar();
}

对于乘法，是一种特殊的加法。

对于除法，不存在溢出。

溢出也会改变标志寄存器的状态：

可以检测标志寄存器来判断是否溢出:

    int flag;
    __asm
    {
        pushfd;    // 标识寄存器内容入栈
        pop flag;  // 复制给一个变量
        push flag; // 被保存的标识入栈
        popfd;     // 复制给标识寄存器
    }

3 整型的截断（Truncation），截掉高位

当较宽的整型赋值给一位较窄的整型时，需要截掉高位来赋值：

long b=70000;   // 0000 0000 0001 0001 0001 0111 0000
short a=b;         // 4464                    0001 0001 0111 0000

较大的long int，当截断后，可能会出现首位是1的情况时，其位数的值的位模式会被译码为一个负值：

long b=57973;   // 0000 0000 0000 1110 0010 0111 0101
short a=b;      // -7563          1110 0010 0111 0101

4 整形提升

不同数据类型在混合运算时，时常会进行整型提升或者强制转换的操作，C语言中提升规则如下图：

当有char、short、signed int的类型混合运算时，都会提升为signed int类型，并作为整体表达式的类型，如果需要赋值给左值，则表达式的类型会自动转换为左值类型。

当有char、short、signed int、unsigned int类型混合运算时，都会提升为unsigned int类型进行运算。

当有char、short、signed int、unsigned int、long类型混合运算时，都会提升为long类型进行运算。

当有char、short、signed int、unsigned int、long类型混合运算时，都会提升为long类型进行运算。

当整型与浮点数混合运算时，会提升为浮点型进行运算。

当无符号整形与有符号整型同时用在关系表达式时，有符号整型会提升为无符号整型，可能会出现令人意想不到的结果，有时就类错误很难排查。

   unsigned int a=4294967290;
    int b=-6; 
    printf("%d\n",a==b); // 1

如strlen()返回的就是一个unsigned int，让类型提升问题更具有隐藏性：

int kmpMatch(char* s, char* t){
    int *next = getNextArray(t);
    int i = 0, j = 0;
    while (i<(int)strlen(s) && j<(int)strlen(t)){
        if(j == -1 || s[i]==t[j]){
            i++;
            j++;
        }
        else
            j = next[j];
    }
    if(j == (int)strlen(t))  // strlen返回的是size_t，其是unsigned int的宏定义，
    // 如果不做转换，j会提升为unsigned
        return i-j;
    else
        return -1;
}

6 浮点数转换为整型时，会截掉小数部分

double d = 15.75;
// 0100 0000 0010 1111 1000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
int a = d;  // 0000 0000 0000 0000 0000 0000 1111
printf("%d\n",a);// a = 15 , 截掉小数

ref

http://m.cplusplus.com/articles/DE18T05o/