Является ли хорошей практикой использовать long int, чтобы избежать переполнения?

Question

Предположим, что я объявил следующие переменные:

some_dataType a,b,c; //a,b,c are positive 
int res; 
res=a+b-c; 

И я была предоставлена ​​информация о том, что переменная res не может пересечь предел целое. Просто, чтобы избежать переполнения из выражения a+b в a+b-c У меня после Options-

1. объявить, Ь, с тех пор ИНТ
2. (a-c) + б
3. (long int) (а + Ьс) // или какой-либо другой литье под давлением

Мой вопрос в том, какая из перечисленных выше является хорошей практикой. Кроме того, чтобы избежать всего этого, я предпочитаю делать вариант 1. Но он может увеличить объем памяти программы (не для этой программы, а для больших приложений).
Предположение: долго ИНТ больше ИНТ Спасибо @Retired Ninja

Answer 1

Там нет простого, вообще, переносимый способ избежать целочисленного переполнения.

Использование более широкого целочисленного типа не является общим решением, поскольку нет гарантии, что существует более широкий целочисленный тип. Для типов int и long очень распространены одинаковые размеры на некоторых системах. 32-разрядные системы обычно составляют как int, так и long 32 бита; даже некоторые 64-битные системы делают то же самое. И некоторые 64-битные системы делают как int, так и long 64 бит.

Вы писали:

И я была предоставлена ​​информация о том, что переменная res не может пересечь предел целое.

Лучше быть осторожным с терминологией. Хотя имя типа int, очевидно, является аббревиатурой слова «целое число», слова не являются синонимами. В C и C++ int является одним из нескольких целых чисел типов; другие включают unsigned char и long long.

Предположительно, что вы имеете в виду, что значение res не должны находиться за пределами диапазона типа int, который INT_MIN к INT_MAX.

Если вы используете long long для получения результата, вероятно, вы сможете избежать переполнения; вы можете сравнить результат с значениями INT_MIN и INT_MAX и предпринять любые корректирующие действия, если это вне пределов досягаемости. Но все же возможно, что и int, и long long будут 64 бит. То, что вы делаете с этим, зависит от того, насколько портативен ваш код.

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

Некоторые компиляторы могут предоставлять функции, которые выполняют безопасную подписанную арифметику и сообщают вам, произошло ли переполнение. Обратитесь к документации вашего компилятора.

Есть способы проверить операнды перед выполнением операции. Они сложны, и я слишком ленив, чтобы работать над деталями, но вкратце:

• Если операнды + имеют противоположные знаки, или если один из операндов имеет 0, добавление является безопасным.
• Если оба операнда положительны, добавление безопасно, если x не превышает INT_MAX - y.
• Если оба операнда отрицательные, добавление безопасно, если y составляет не менее INT_MIN - y.

Я не гарантирую, что приведенное выше полностью верно * Я просто написал это с головы), но в большинстве случаев это, вероятно, больше усилий, чем того стоит.

Answer 2

Доверяй, но проверяй:

assert(a > 0); 
assert(b > 0); 
assert(c > 0); 
assert((long)a - (long)c + (long)b <= INT_MAX); 

int res = a - c + b;