Переполнение целочисленного значения со знаком в С++?

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

Это непроверенный код, но вам, вероятно, понадобится что-то вроде следующего:

if(b != 0) {
    auto max_a = std::numeric_limits<int64_t>::max() / b;
    if(max_a < a) {
        throw std::runtime_error{"overflow"};
    }
}
return a * b;

Обратите внимание, что этот код не обрабатывает потерю значимости; если a * b может быть отрицательным, эта проверка не сработает.

Согласно Godbolt, вы можете видеть, что в вашей версии проверка полностью оптимизирована.

Переполнение целого числа со знаком — это неопределенное поведение в C++.

Это означает, что оптимизатор может предположить, что этого никогда не произойдет. a*b/b это a, и точка.

Современные компиляторы выполняют статическую оптимизацию на основе одиночного присваивания.

// a and b are int64_t
int64_t product = a * b;
if (b != 0 && product / b != a) {
  // Overflow
}

становится:

const int64_t __X__ = a * b; 
const bool __Y__ = b != 0;
const int64_t __Z__ = __X__ / b;
const int64_t __Z__ = a*b / b;
const int64_t __Z__ = a;

if (__Y__ && __Z__ != a) {
  // Overflow
}

который оценивается как

if (__Y__ && false) {
  // Overflow
}

ясно, что __Z__ это a, а a!=a это false.

int128_t big_product = a * b; 

работать с big_product и обнаруживать там переполнение.

SSA позволяет компилятору реализовать такие вещи, как (a+1)>a всегда верно, что может упростить многие циклы и случаи оптимизации. Этот факт основан на том факте, что переполнение значений со знаком является неопределяемым поведением.

Зная этоproduct == a * b, компилятор/оптимизатор может предпринять следующие шаги по оптимизации:

b != 0 && product / b != a
b != 0 && a * b / b != a
b != 0 && a * 1 != a
b != 0 && a != a
b != 0 && false
false

Оптимизатор может полностью удалить ветвь.

Я понимаю, что переполнение целого числа со знаком является «неопределенным поведением» в C++, поэтому поведение компилятора может меняться в разных реализациях. Но может ли кто-нибудь помочь мне понять вышеописанное поведение?

Возможно, вы знаете, что переполнение целого числа со знаком — это UB, но я полагаю, вы еще не поняли, что на самом деле означает UB. UB не нужен, и часто не имеет смысла. Хотя этот случай кажется прямолинейным.

может ли кто-нибудь помочь мне понять вышеописанное поведение?

Переполнение целого числа со знаком имеет неопределенное поведение в C++. Это означает, что вы не можете надежно его обнаружить, и что код, содержащий переполнение целого числа со знаком, может делать что угодно.

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

Целочисленное переполнение со знаком является неопределенным поведением. Это отличается от unsigned int (все беззнаковые целые). Дополнительная информация об этом here

В качестве примечания люди заметили, что использование int вместо unsigned int увеличивает производительность (см. unsigned-int">здесь), так как компилятор не имеет дело с переполнением.

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

https://gmplib.org/

вы можете прочитать эту документацию, она может быть вам полезна, как если бы у меня возникла какая-либо проблема с переменными и типами данных, я сразу же прочитаю ее: http://www.cplusplus.com/doc/tutorial/variables/