Почему не делает C, имеют неподписанные плавания?

Существует значительная разница между целыми числами со знаком и целыми числами без знака в C/C++:

value >> shift

значения со знаком оставляют главный бит без изменений (знак расширяются), неподписанные значения очищают главный бит.

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

float a = 2.0f, b = 10.0f, c;
c = a - b;

, Что имеет значение c?-8. Но что это означало бы в системе без отрицательных чисел. FLOAT_MAX - 8, возможно? На самом деле это не работает, поскольку FLOAT_MAX - 8 FLOAT_MAX из-за эффектов точности, таким образом, вещи еще более странны. Что, если это была часть более сложного выражения:

float a = 2.0f, b = 10.0f, c = 20.0f, d = 3.14159f, e;
e = (a - b) / d + c;

Это не проблема для целых чисел из-за природы 2's дополнительная система.

Также рассматривают стандартные математические функции: грех, потому что и загар только работал бы на половину их входных значений, Вы не могли найти журнал значений < 1, Вы не могли решить квадратные уравнения: x = (-b +/-корень (b.b - 4.a.c)) / 2.a, и так далее. На самом деле это, вероятно, не работало бы ни на какую комплексную функцию, поскольку они имеют тенденцию быть реализованными как полиномиальные приближения, которые использовали бы отрицательные величины где-нибудь.

Так, неподписанные плавания довольно бесполезны.

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

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

плавание А имеет намного большее поле, таким образом, никогда не было 'физической' потребности в неподписанном плавании. И поскольку Вы указываете на себя в своем вопросе, дополнительная точность на 1 бит - ничто для уничтожения для.

Редактирование: После чтения эти ответ Brian R. Bondy , я должен изменить свой ответ: Он определенно прав, что базовые центральные процессоры не начинали неподписанные операции плавающие. Однако я поддерживаю свою веру, что это было проектным решением на основе причин I вышеизложенный ;-)

Я думаю, что Treb на правильном пути. Для целых чисел более важно, чтобы у Вас был неподписанный соответствующий тип. Это - те, которые используются в смещение бита и используются в битовые массивы . Знаковый бит просто входит в путь. Например, смещение права отрицательная величина, получающееся значение является реализацией, определенной в C++. Выполнение этого с целым числом без знака или переполнение такого отлично определили семантику, потому что нет такого бита в пути.

Так для целых чисел, по крайней мере, потребность в отдельном неподписанном типе более сильна, чем просто предоставление предупреждений. Все вышеупомянутые вопросы не должны быть рассмотрены для плаваний. Так, существует, я думаю, никакая реальная потребность в поддержке оборудования для них, и C уже сделает не, поддерживают их в той точке.

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

статья Википедии о числах с плавающей точкой IEEE

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

квадратный корень А никогда не будет определенно возвращать отрицательное число. Существуют другие места также, где отрицательное значение плавающее не имеет никакого значения. Идеальный кандидат на неподписанное плавание.

C99 поддерживает комплексные числа и тип универсальная форма sqrt, таким образом sqrt( 1.0 * I) будет отрицательно.

комментаторы выделили небольшой блеск выше, в котором я обращался к универсальному типом sqrt макрос, а не функция, и это возвратит скалярное значение с плавающей точкой усечением комплекса к его реальному компоненту:

#include <complex.h>
#include <tgmath.h>

int main () 
{
    complex double a = 1.0 + 1.0 * I;

    double f = sqrt(a);

    return 0;
}

Это также содержит заскок, поскольку действительная часть sqrt любого комплексного числа положительна или нуль, и sqrt (1.0*I) является sqrt (0.5) + sqrt (0.5) *I не-1.0.

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

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

(Как в стороне, Perl 6 позволяет Вам записать

subset Nonnegative::Float of Float where { $_ >= 0 };

и затем можно использовать Nonnegative::Float точно так же, как Вы были бы любой другой тип.)

Нет никакой поддержки оборудования для неподписанных операций с плавающей точкой, таким образом, C не предлагает его. C главным образом разработан, чтобы быть "портативным блоком", то есть, как близко к металлу, как можно быть, не будучи привязанным к определенной платформе.

[править]

C похож на блок: то, что Вы видите, точно, что Вы получаете. Неявное "я проверю, что это плавание является неотрицательным для Вас", идет вразрез с его принципами проектирования. Если Вы действительно хотите это, можно добавить assert(x >= 0) или подобный, но необходимо сделать это явно.