c语言中求最大值最小值和平均值（C整型的最值）
c语言中求最大值最小值和平均值（C整型的最值）溢出检测：然而，如果计算它们的和，我们就有一个可能的范围。表示这个和可能需要w 1位，对于有限字长的无符号整数加法，其多出的一位就会截断，也就是溢出或模的运算。#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
整数在计算机内以有限字长表示，当超出最值（有限字长）时，需要截断（溢出，求模）操作。
不同字长的整型具有不同的值域，混合运算时，需要类型提升和转换。
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 01014 整形提升
不同数据类型在混合运算时，时常会进行整型提升或者强制转换的操作，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/
