У меня возникла проблема с преобразованием численных типов между собой, а это: int, long, long long, float, double.

Вся проблема в том, что по идее преобразование одно из этих типов в другой, должно преобразовывать само значение с учетом границ типа, в которое оно преобразовывается.

На практике получается, что при преобразовании положительного числа, например, long long (2e20, т.е. получаем выход за границы типа int) в int на выходе получаем максимальное отрицательное число (т.е. отрицательную границу или ближе к ней), вместо положительной максимальной границы. У преобразования double в float с выходом за границы второго типа, выдает "inf". При преобразовании не превышающем границы конечного типа, значение не изменяется.

Например, тип переменной long long со значением 2e10 преобразуется в тип int со значением -1474836480, а при значении -2e10 выдает 1474836480.


Вопрос тут такой, как лучше и правильнее реализовать преобразование чисел с проверкой границ математическим способом? И не будет ли искажений в вычислениях, если я переопределю операторы преобразования, где будет стоять проверка границ с записыванием значения границы при ее превышении?

В добавок, int может иметь (скорее всего в 16-битной ОС) может иметь 2/4 байта в зависимости от ОС.

Хм, понятно. Значит самый простой вариант, при необходимости использовать разные типы чисел, это проверять границы и вручную контролировать этот процесс, как мы это делаем в массивах, раз внутри границ конечного типа все работает как надо.

Тогда возникает вопрос. Есть ли возможность проверки границ константными значениями границ численных типов, т.е. возможно ли узнать о граничном значении типа с помощью какой-нибудь функции, как например sizeof показывает кол-во байт, занимаемое типом в памяти? Или эти значения придется брать из справочника?

Я этот вопрос задаю к тому, что с целыми все просто их граничные значения высчитываются математикой, например для int (тут без разницы, 2 или 4 байта, границы будут верными на текущей ОС):

А как быть для вещественных чисел? Брать граничные значения из справочника?

Ну преобразовали Вы 1.0e+20 в MAX_INT и толку? Что делать с "преобразованным" и как его пользовать?

Лучше всего решать это "на уровне задачи". Если напр. длина вектора меньше некоторого epsilon (часто 1.0e-5f), то нормировать его нельзя, это крайний случай который должен отрабатываться. Также если в расчетах значения начинают превышать некоторое значение (типа 1.0e+10) - это просто значит что расчеты идут вразнос и на следующем шаге уже получим nan. Это должно пресекаться подсечкой или остановкой расчетов.

Все работает "с какой-то точностью и в каких-то пределах", и задача которую Вы ставите непонятна.

Не все ситуации требуют присечения. У меня, например, больше нужда проконтролировать, чтобы не выходило за границы. Тем более, получить MAX_INT в своих действиях будет наглядней свидетельствовать, о превышении границы. А в некоторых случаях нужно перевести из большего в меньший с усеканием до макс. границы меньшего типа.

Т.е. у меня есть класс NNumeric (он целесообразен, случае с моим проигрывателем и в предметной области Интерактивная Литература). NNumeric хранит значения чисел во float, но есть нужда выдавать/работать его/с ним и в целых типах, точнее он работает, либо как целый тип, либо как вещественный тип float, потому, что float превышает границы int и long, то мне хватает одного его для хранения (long и float оба занимают по 4 байта) значения. Т.о. этот класс реализован для хранения значений переменных и чисел (константых значений) для хранения и обработки этих значений, поступающих на вход исполнителя посредством формального языка.  

Учитывая абзац выше, мне удобнее, не приостанавливать программу (тем более, что предметная область не располагает к описанным вами математическим расчетам и по сложнее), а записать ту границу типа, которое значение превышает. А также просто вести контроль границ, чтобы не было останова из-за превышения границ во время исполнения программы и последующего ее вылета.  

З.Ы.
Мне бы не хотелось выходить за тему, дальше двух абзацев выше. Написал, только лишь для ответа на вопрос Igors-а. 

Кхм, столкнулся с интересной ситуацией. С целыми числами у меня получилось, но с вещественными все оказалось куда сложнее. Точнее говоря, я и для них проверку написал (см. код ниже), но меня смутил один момент. Минимальная граница отличается от заявленной в справочниках по Си++ (точнее она в половину меньше числа для максимума, но с 'e-38'). Как тут быть?

Собственно, код:
Первых два условия проверяют, как и в случае для целых чисел, максимальные полож. и отриц. границы. А два последних условия проверяют максимальное и минимальное значение для чисел между -1..0 и 0..1, т.е. для чисел после запятой.

При максимуме я получил ~+/-3.4e38, а при минимуме я получил ~+/-1.7e-38 (в справочниках было +/-3.4e-38).

В общем, я все правильно написал или что-то упустил из внимания?

Для флотов вся эта песня лишена смысла, т.к, если value = nan. то любое сравнение вернет false.
Надо задействовать fpclassify

Мне всегда INF попадалось при переходе за границы и все работало, т.е. сравнения шли и границы записывались. А в чем собственно различие INF и NAN?

Мне как-то не посчастливилось найти нормальное описание INF и NAN в СИ++, можете дать отсылку к такому материалу? 

это не дело Си/С++, это дело общего стандарта(IEEE754). Вот  перевод на русский. Там вообще много всего интересного. то о чём мы говорили(nan и inf) расписываются в п. 6.
про то как проще всего получить их на Си:

C
#include <cstdio>
 
int main(int , char *[])
{
	float f=1;
	f=0;
	f=1/f;
	printf("INF: %e\n",f);
	f=0;
	f=0/f;
	printf("NAN: %e\n",f);
	f=0;
	f=-1/f;
	printf("-INF: %e\n",f);
 
	return 0;
}
 

[added]
почитал там примеры ошибок... как же страшно жить, работая с плавующей точкой...