Является ли использование неподписанного, а не подписанного int более вероятным причиной ошибок? Зачем?

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

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

Беззнаковые значения имеют разрыв в нуле, наиболее распространенное значение в программировании

И целые числа без знака и со знаком имеют разрывы в их минимальных и максимальных значениях, где они переносятся (без знака) или вызывают неопределенное поведение (со знаком). За unsigned эти точки в нуль а также UINT_MAX, За int они в INT_MIN а также INT_MAX, Типичные значения INT_MIN а также INT_MAX в системе с 4 байтами int значения -2^31 а также 2^31-1и по такой системе UINT_MAX обычно 2^32-1,

Основная проблема с ошибками unsigned это не относится к int в том, что у него есть разрыв в нуле. Ноль, конечно, является очень распространенным значением в программах, наряду с другими небольшими значениями, такими как 1,2,3. Обычно складывают и вычитают небольшие значения, особенно 1, в различных конструкциях, а если вы вычитаете что-либо из unsigned значение, и оно оказывается равным нулю, вы только что получили огромное положительное значение и почти определенную ошибку.

Рассмотрим код, повторяющий все значения в векторе по индексу, кроме последнего^0,5:

for (size_t i = 0; i < v.size() - 1; i++) { // do something }

Это работает нормально, пока однажды вы не передадите пустой вектор. Вместо того, чтобы делать ноль итераций, вы получаете v.size() - 1 == a giant number¹ и вы сделаете 4 миллиарда итераций и почти будете иметь уязвимость переполнения буфера.

Вам нужно написать это так:

for (size_t i = 0; i + 1 < v.size(); i++) { // do something }

Таким образом, это может быть «исправлено» в этом случае, но только путем тщательного размышления о беззнаковой природе size_t, Иногда вы не можете применить вышеупомянутое исправление, потому что вместо константы у вас есть переменное смещение, которое вы хотите применить, которое может быть положительным или отрицательным: так, на какую «сторону» сравнения вам нужно поставить, зависит от подписи — теперь код получает действительно беспорядочный.

Существует аналогичная проблема с кодом, который пытается выполнить итерирование вплоть до нуля. Что-то вроде while (index-- > 0) работает нормально, но, видимо, эквивалент while (--index >= 0) никогда не завершится для значения без знака. Ваш компилятор может предупредить вас, когда правая часть буквальный ноль, но, конечно, нет, если это значение определяется во время выполнения.

контрапункт

Некоторые могут возразить, что подписанные значения также имеют две несплошности, так зачем выбирать неподписанные? Разница в том, что оба разрыва очень (максимально) далеки от нуля. Я действительно считаю, что это отдельная проблема «переполнения», при этом значения со знаком и без знака могут переполняться при очень больших значениях. Во многих случаях переполнение невозможно из-за ограничений на возможный диапазон значений, а переполнение многих 64-битных значений может быть физически невозможно). Даже если это возможно, вероятность ошибки, связанной с переполнением, часто ничтожна по сравнению с ошибкой «в ноль», и переполнение происходит и для неподписанных значений. Таким образом, unsigned сочетает в себе худшее из обоих миров: потенциальное переполнение с очень большими значениями величины и разрыв в нуле. Подписано только бывшее.

Многие будут утверждать, что «вы немного потеряете» с неподписанным. Это часто верно, но не всегда (если вам нужно представить разницу между значениями без знака, вы все равно потеряете этот бит: так много 32-битных вещей в любом случае ограничено 2 ГБ, или у вас будет странная серая область, где, скажем, файл может быть 4 ГиБ, но вы не можете использовать определенные API во второй половине 2 ГБ).

Даже в тех случаях, когда unsigned покупает вас немного: он мало что покупает: если вам нужно было поддерживать более 2 миллиардов «вещей», вам, вероятно, скоро придется поддерживать более 4 миллиардов.

Логически, неподписанные значения являются подмножеством подписанных значений.

Математически, беззнаковые значения (неотрицательные целые числа) являются подмножеством целых чисел со знаком (просто называемых _integers).². Еще подписанный значения естественно всплывают из операций исключительно на неподписанный значения, такие как вычитание. Мы можем сказать, что неподписанные значения не закрыто под вычитанием. То же самое не относится к подписанным значениям.

Хотите найти «дельту» между двумя беззнаковыми индексами в файле? Что ж, вам лучше сделать вычитание в правильном порядке, иначе вы получите неправильный ответ. Конечно, вам часто требуется проверка во время выполнения, чтобы определить правильный порядок! Имея дело со значениями без знака в виде чисел, вы часто обнаруживаете, что (логически) значения со знаком продолжают появляться в любом случае, так что вы могли бы также начать со знака.

контрапункт

Как упоминалось в сноске (2) выше, подписанные значения в C ++ на самом деле не являются подмножеством беззнаковых значений одинакового размера, поэтому беззнаковые значения могут представлять то же число результатов, что и подписанные значения.

Правда, но диапазон менее полезен. Рассмотрим вычитание и числа без знака с диапазоном от 0 до 2N, а также числа со знаком с диапазоном от -N до N. Произвольные вычитания приводят к результатам в диапазоне от -2N до 2N в обоих случаях, и любое целое число может представлять только половина этого. Хорошо получается, что область вокруг нуля от -N до N обычно более полезна (содержит больше фактических результатов в коде реального мира), чем диапазон от 0 до 2N. Рассмотрим любое типичное распределение, отличное от равномерного (log, zipfian, normal и т. Д.), И рассмотрим вычитание случайно выбранных значений из этого распределения: гораздо больше значений заканчивается в [-N, N], чем [0, 2N] (действительно, в результате получается распределение всегда в центре нуля).

64-разрядная версия закрывает двери по многим причинам использовать подписанные значения в качестве чисел

Я думаю, что приведенные выше аргументы уже были убедительными для 32-битных значений, но случаи переполнения, которые влияют как на подпись, так и на беззнаковое при различных порогах, делать встречаются для 32-битных значений, поскольку «2 миллиарда» — это число, которое может превышать многие абстрактные и физические величины (миллиарды долларов, миллиарды наносекунд, массивы с миллиардами элементов). Таким образом, если кто-то достаточно убежден удвоением положительного диапазона для беззнаковых значений, он может доказать, что переполнение имеет значение, и оно слегка благоприятствует беззнаковому.

За пределами специализированных доменов 64-битные значения в значительной степени устраняют эту проблему. 64-битные значения со знаком имеют верхний диапазон 9 223 372 036 854 775 807 — более девяти нониллион. Это много наносекунд (около 292 лет) и много денег. Это также больший массив, чем у любого компьютера, который может иметь ОЗУ в согласованном адресном пространстве в течение длительного времени. Так что, может быть, 9 квинтиллионов хватит всем (пока)?

Когда использовать неподписанные значения

Обратите внимание, что руководство по стилю не запрещает или даже не поощряет использование чисел без знака. Он заканчивается:

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

Действительно, есть хорошие применения для беззнаковых переменных:

• Когда вы хотите обрабатывать N-разрядное число не как целое число, а просто как «мешок с битами». Например, в качестве битовой маски или растрового изображения, или N логических значений или чего-либо еще. Это использование часто идет рука об руку с фиксированными типами ширины, такими как uint32_t а также uint64_t так как вы часто хотите знать точный размер переменной. Намек на то, что определенная переменная заслуживает такого обращения, заключается в том, что вы работаете с ней только с помощью побитовое такие операторы, как ~, |, &, ^, >> и так далее, а не с арифметическими операциями, такими как +, -, *, / и т.п.

  Без знака здесь идеально, потому что поведение побитовых операторов четко определено и стандартизировано. У значений со знаком есть несколько проблем, таких как неопределенное и неопределенное поведение при сдвиге и неопределенное представление.

• Когда вы на самом деле хотите модульную арифметику. Иногда вы действительно хотите 2 ^ N модульной арифметики. В этих случаях «переполнение» — это функция, а не ошибка. Значения без знака дают вам то, что вы хотите, поскольку они определены для использования модульной арифметики. Подписанные значения нельзя (легко, эффективно) использовать вообще, поскольку они имеют неопределенное представление, а переполнение не определено.

---

^0,5 После того, как я написал это, я понял, что это почти идентично Пример Джарода, которого я не видел — и для этого есть хороший пример!

¹ Мы говорим о size_t здесь обычно 2 ^ 32-1 в 32-битной системе или 2 ^ 64-1 в 64-битной.

² В C ++ это не совсем так, потому что беззнаковые значения содержат больше значений в верхнем конце, чем соответствующий подписанный тип, но существует основная проблема, заключающаяся в том, что манипулирование беззнаковыми значениями может привести к (логически) знаковым значениям, но нет соответствующей проблемы с значения со знаком (так как значения со знаком уже включают в себя значения без знака).

for (int i = 0; i < v.size() - 5; ++i) { foo(v[i]); } // Incorrect
// for (int i = 0; i + 5 < v.size(); ++i) { foo(v[i]); } // Correct

#include <iostream>
int main()  {
auto qualifier = -1 < 1u ? "makes" : "does not make";
std::cout << "The world " << qualifier << " sense" << std::endl;
}