Компилятор работает с исходным кодом в виде строк, например, в C ++, например, когда он поощряет оператор типа unsigned char x = 150;, он знает из пределов типа, что unsigned char должен находиться в диапазоне от 0 до 255.
У меня вопрос, пока число 150 остается строкой, какой компилятор алгоритма использует для сравнения последовательности цифр - 150 в данном случае - с ограничениями типов?
Я сделал простой алгоритм, чтобы сделать это для типа 'int'для десятичного, восьмеричного, шестнадцатеричного и двоичного числа с прямым порядком байтов, но я не думаю, что компилятор делает такую вещь, чтобы обнаружить переполнение в числах.
алгоритм, который я сделал, написан на C ++:
typedef signed char int8;
typedef signed int int32;
#define DEC 0
#define HEX 1
#define OCT 2
#define BIN 3
bool isOverflow(const char* value, int32 base)
{
// left-most digit for maximum and minimum number
static const char* max_numbers[4][2] =
{
// INT_MAX INT_MIN
{ "2147483647", "2147483648" }, // decimal
{ "7fffffff", "80000000" }, // hexadecimal
{ "17777777777", "20000000000" }, // octal
{ "01111111111111111111111111111111", "10000000000000000000000000000000" } // binary
};
// size of strings in max_numbers array
static const int32 number_sizes[] = { 10, 8, 11, 32 };
// input string size
int32 str_len = strlen(value);
// is sign mark exist in input string
int32 signExist = ((base == DEC || base == OCT) && *value == '-');
// first non zero digit in input number
int32 non_zero_index = signExist;
// locate first non zero index
while(non_zero_index < str_len && value[non_zero_index] == 0) non_zero_index++;
// if non_zero_index equal length then all digits are zero
if (non_zero_index == str_len) return false;
// get number of digits that actually represent the number
int32 diff = str_len - non_zero_index;
// if difference less than 10 digits then no overflow will happened
if (diff < number_sizes[base]) return false;
// if difference greater than 10 digits then overflow will happened
if (diff > number_sizes[base]) return true;
// left digit in input and search strings
int8 left1 = 0, left2 = 0;
// if digits equal to 10 then loop over digits from left to right and compare
for (int32 i = 0; non_zero_index < str_len; non_zero_index++, i++)
{
// get input digit
left1 = value[non_zero_index];
// get match digit
left2 = max_numbers[signExist][i];
// if digits not equal then if left1 is greater overflow will occurred, false otherwise
if (left1 != left2) return left1 > left2;
}
// overflow won't happened
return false;
}
Этот алгоритм может быть оптимизирован для работы со всеми целыми типами, но с плавающей точкой мне нужно создать новый для работы с представлением с плавающей точкой IEEE.
Я думаю, что компиляторы используют эффективный алгоритм для обнаружения переполнения, другогочем мой, не так ли?