Здравствуйте, Erop, Вы писали:

Вот скажем такая простая штука, как unsigned(-1) % 10 уже равна неизвестно чему)

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

Возьмём ваш пример с"-1" для 32-х разрядного регистра

"1" — это 0x00000001,

проинвертируем поразрядно, получим:

0xFFFFFFFE

Теперь прибавим единицу, получим:

0xFFFFFFFF

Таким образом дополнительный код числа "-1" — 0xFFFFFFFF, при приведении типов, в переменную типа unsigned int запишется именно 0xFFFFFFFF, в десятичной системе счисления это составляет 4 294 967 295. Явно видно, что остаток деления на 10 будет 5.

Здравствуйте, Максим2006, Вы писали:
М>Предлагаю послушать старейшин...
Страуструп пишет в книге "Язык программирования C++" (третье издание) в конце главы 4:

4.10. Советы
...
[18] Избегайте беззнаковой арифметики; § 4.4.
[19] С подозрением относитесь к преобразованиям из signed в unsigned и из unsigned в signed; § В.6.2.6.

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, Erlond, Вы писали:

E>>>Предатавь себе, что знаковые числа хранятся в виде мантисы и знака, например
E>>Не представляю. При чем тут это? Мы рассмотриваем сечас int и unsigned int.

E>А такие реализации таки бывают

Бывают, я же не говорил, что их не бывает. Я привёл конкретный пример с типами int и unsigned int. И задал по нему вполне конкретный вопрос.
Здесь идёт разговор о целых знаковых и целых беззнаковых числах, числа с плавающей запятой выходят за рамки этой дискуссии, т.к. они не являются целыми и т.к. они всегда знаковые

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, Кодт, Вы писали:

К>>Здравствуйте, Максим2006, Вы писали:

К>>Модулярная арифметика может трактоваться как частный случай UB Так что unsigned замечательно справляется с обеими ролями.

E>Да плохо она справляется.

E>Например, как всё-таки вычислить корректно разность двух unsigned чисел, ессли больше может быть любое?

Как вариант:

void main()
{
    unsigned int a, b, c;

    std::cin >> a >> b;

    c = (a > b) ? a - b : b - a;

    std::cout << c << std::endl;    
};

Здравствуйте, Erop, Вы писали:

E>или это он всё писал для секретарш иногда применяющих С++ для своих нужд

Здравствуйте, Андрей Тарасевич, Вы писали:

АТ>В общем, "старейшин" надо уважать, но, скажем так, понимать, что все, что они говорят — это лишь монетка на ту или иную чашу весов. И, возможно, предназначавшаяся совсем не для ваших весов...

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

Приведу иллюстрирующий пример, хотя и не связанный со знаковостью. Я как-то участвовал в написании системки для работы с некоторыми специфическими документами для одной из госорганизаций. Особенность этих документов в том, что по-идее не могли никак, ну никак не могли иметь разные документы одинаковый номер -- это не просто так документы были, с этим номером государственная организация выдаёт Важные Бумаги и не может быть одинакового номера на бумаге для Лица А и Лица Б. Вы, наверное, уже догадались, что когда системка прошла тестирование и была введена в эксплуатацию выяснилось, что невозможное всё-таки оказалось иногда возможно Для руководства этой организации сей факт стал скандальным. Хорошо, что этот номер не сделали уникальным ключом в базе, хотя и хотели сильно.

Здравствуйте, Erlond, Вы писали:

E>Очень просто, в компльютере числа представляются в дополнительном коде. Дополнительный код положительного числа равен самому числу, а чтобы получить дополнительный код отрицательно числа, нужно празрядно проинвертировать число, а затем, к тому что получилось прибавить 1.

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

Здравствуйте, Michael7, Вы писали:

M>Здравствуйте, Erlond, Вы писали:

E>>Очень просто, в компльютере числа представляются в дополнительном коде. Дополнительный код положительного числа равен самому числу, а чтобы получить дополнительный код отрицательно числа, нужно празрядно проинвертировать число, а затем, к тому что получилось прибавить 1.

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

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

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

M>>Чем? На мой взгляд существует очень ограниченный перечень случаев, когда unsigned оправдан, это флаги, коды значений, работа с памятью, может ещё пара случаев и всё. В принципе, ещё можно даже для арифметических операций, если не хватает диапазона значений знакового типа, но это уже грязный стиль и нежелательно.
Полностью поддерживаю.

АТ>Чем — это очень странный вопрос. Беззнаковые по своей природе сущности естественно представлять беззнаковыми типами. Тут, собственно, и вопросов никаких нет.
То есть ты используешь unsigned чтобы подчеркнуть что переменная не может содержать отрицательные значения?

Или чтобы выгадать еще один бит? Или и то и то?

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

АТ>Вопросы возникают именно тогда, когда кто-то начинает пытаться использовать знаковые типы для это цели. Вот тут действительно можно спросить, чем это вдруг оправданно такое странное использование знаковых типов.
Эээ... Наоборот, вопрос возникнет по какой такой причине программист использовал unsigned вместо signed. За желание выгадать еще один бит — нужно отрывать руки.

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

АТ>И в большинестве случаев оказывается, что знаковые типы просто-напросто чаще "прощают" беспечное отношение к коду.
В знаковых типах просто не происходит потери информации, и это уже дает кое-какие гарантии и вовсе не свидетельствует о беспечном отношении к коду. Наоборот, желание делать все как "правильно" (хранить неотрицательные сущности в беззнаковых переменных) может повредить.

АТ>Во-первых, я считаю, что правильнее внимательнее относиться к коду, а не пытаться компенсировать лень использованием знаковых типов. Во-вторых, "безопасность" знаковых типов — не более чем иллюзия.
Ты серьезно считаешь что программистам лениво написать unsigned для всех неотрицательных сущностей? Респект!

На счет более внимательного отношения к коду — согласен. Только внимательность должна проявляться не в делании типа беззнаковым, а брать тип (не обязательно integral) с большим числом битов если их не хватает.

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

Или представь такую простую задачу. Ты получаешь площади квадратов, очень большие положительные числа. Согласно твоей логике, и стороны квадрата и сама площадь не могут быть отрицательными — поэтому ты их делаешь unsigned. Тебе надо найти их сторону. Для этого ты, скорее всего, воспользуешся стандартной функцией которая принимает double. И теперь вопрос, положительное или отрицательное число окажется в самой функции? Мой ответ — я не знаю но я твердо знаю что если signed будет конвертированно в double, то знак останется.

M>>Сугубо моё мнение, но у меня сложилось впечатление, что потенциальные проблемы
У меня также ибо происходит потеря информации — знак числа.

АТ>Я не знаком ни с какими "потенциальными проблемами" беззнаковых типов. В моем коде, например, практически все целочисленные типы — беззнаковые, за исключением случаев, когда действительно приходится работать со знаковой величиной.
Я выше уже сказал главную проблему беззнаковых типов — потеря информации.

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

АТ> Я не вижу абсолютно никаких проблем с прозрачностью кода.

M>>Например, казалось бы логично сделать индекс/счётчик беззнаковым, но в дальнейшем может оказаться, что проще всего присваивать ему отрицательные значения для обработки особых ситуаций.

АТ>А вот это — идеологически неправильно.
Это еще почему? Например, делаем линейный поиск в массиве. Не нашли элемент, вернули -1. Можно, конечно, вернуть индекс сразу за концом массива, но если следовать такой логике, то NULL тоже возвращаться из функций при работе с указателями нельзя.

АТ>Также стоит упомянуть, что в С++ во многих контекстах выбор в пользу знаковых типов сдела на уровне языка и стандартной билиотеки. Сделан давно и навсегда. Это и 'size_t', и 'sid::vector<>:size_type' и т.п.
Это не аргумент. Там тоже люди, и они могли не представлять к каким последствиям это может привести. Сдается мне что беззнаковые типы они выбрали по причине что неотрицательные числа "должны" представляться беззнаковыми числами (то что ты и говоришь) а не чтобы выгадать один бит. И тем не менее сам Бьярн использует int в циклах, к примеру, хотя если уж следовать стандарту, то он должен был бы писать unsigned.

E>>>>signed -- для чисел
E>>>>unsigned -- для флажков.
Ш>>>По-моему, это та простота, которая хуже воровства.

E>>Ну прости, я ответил на вопрос, что же я таки думаю.
E>>ИМХО выгоды от использования беззанковых чисел всегда какие-то призрачные.

Ш>Речь идет не а выгодах. Речь идет о том, зачем вообще нужна беззнаковая арифметика (см. заглавную тему).
Ш>Она нужна для решения огромного количества задач.

Ш>Например, напиши struct IPHeader без беззнаковых типов. Или сделай алгоритм вычисления CRC (а так же SHA, DES, длинная арифметика и.т.п.).
То есть ты прибавляешь один IP к другому, а порты отнимаешь друг от друга и две получившиеся величины перемножаешь между собой?

К>>Модулярная арифметика может трактоваться как частный случай UB Так что unsigned замечательно справляется с обеими ролями.

E>Да плохо она справляется.
E>Например, как всё-таки вычислить корректно разность двух unsigned чисел, ессли больше может быть любое?

Ты не понял!
С арифметикой по модулю она справляется.
А с человеческой — честно реализует undefined behavior, как и просил Максим. Или ты хочешь, чтобы UB всегда форматировало диск?

Здравствуйте, Erlond, Вы писали:

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

Ну хорошо, такая вот попытка: (1u — 2u) % 10 месье устроит?

Здравствуйте, Erlond, Вы писали:

E>Таким образом дополнительный код числа "-1" — 0xFFFFFFFF, при приведении типов, в переменную типа unsigned int запишется именно 0xFFFFFFFF, в десятичной системе счисления это составляет 4 294 967 295. Явно видно, что остаток деления на 10 будет 5.

За лекбез спасибо, но
1) Нет никакой гарантии, что на всех машинах будет двоичный доп. код и будет 32-разрядный int.
2) Тот, кто программирует "просто числа", скажем производительность Васи или итерацию массива, при использовании беззнаковой арифметики всё время должен помнить обо всех этих особенностях реализации Кто-нибудь наконец ответит за ради чего?

Здравствуйте, Аноним, Вы писали:

АТ>>Также стоит упомянуть, что в С++ во многих контекстах выбор в пользу знаковых типов сдела на уровне языка и стандартной билиотеки. Сделан давно и навсегда. Это и 'size_t', и 'sid::vector<>:size_type' и т.п.
А>Это не аргумент. Там тоже люди, и они могли не представлять к каким последствиям это может привести. Сдается мне что беззнаковые типы они выбрали по причине что неотрицательные числа "должны" представляться беззнаковыми числами (то что ты и говоришь) а не чтобы выгадать один бит. И тем не менее сам Бьярн использует int в циклах, к примеру, хотя если уж следовать стандарту, то он должен был бы писать unsigned.


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

Здравствуйте, Erlond, Вы писали:

E>Бывают, я же не говорил, что их не бывает. Я привёл конкретный пример с типами int и unsigned int. И задал по нему вполне конкретный вопрос.
E>Здесь идёт разговор о целых знаковых и целых беззнаковых числах, числа с плавающей запятой выходят за рамки этой дискуссии, т.к. они не являются целыми и т.к. они всегда знаковые

Собственно для тех участников обсуждения, ктьо не знает всех подрбностей.
Весь сыр-бор происходит от того, что аппаратура вольна представлять знаковые целые числа как ей заблагорассудится.
И стандарт С++ не навязывает ей двоичного-дополнительного кода.
Так что бывают реализации С++, в которых int реализован как бит занака и unsigned мантиса. Увы.

Здравствуйте, saproj, Вы писали:

E>>Так всё-таки ответ на вопрос "почему лучше" будет каким? )

S>Все уже сказано. Мною в последней строке этого

Автор: saproj
Дата: 16.11.06

сообщения. Другими людьми тоже сказано не раз. Обрати внимание как терпеливо и подробно объясняет Андрей Тарасевич. Не лишне будет еще раз сосредоточенно прочитать.

То есть ответ такой: "потому, что использование типа int для числа деталей менее понятно, чем использование unsigned int"?

А если расшифровать, что каждый из типов обозначает в языке C++, он выглядит совсем уж чуднО: "Потому, что использование знаковой арифметики, не позволяющей работать с числами сильно превышающими миллиард для работы с количеством деталей менее понятно, чем использование арифметики по модулю 0х1000000"?

Это вот утверждение можно как-то аргументировать? Или это какое-то изотерическое атомарное знание?

Андрей очень много и часто содержательно пишет, но совсем не про это, а про что-то другое.

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, Erlond, Вы писали:

E>>Бывают, я же не говорил, что их не бывает. Я привёл конкретный пример с типами int и unsigned int. И задал по нему вполне конкретный вопрос.
E>>Здесь идёт разговор о целых знаковых и целых беззнаковых числах, числа с плавающей запятой выходят за рамки этой дискуссии, т.к. они не являются целыми и т.к. они всегда знаковые

E>Собственно для тех участников обсуждения, ктьо не знает всех подрбностей.
E>Весь сыр-бор происходит от того, что аппаратура вольна представлять знаковые целые числа как ей заблагорассудится.
E>И стандарт С++ не навязывает ей двоичного-дополнительного кода.
E>Так что бывают реализации С++, в которых int реализован как бит занака и unsigned мантиса. Увы.

А на каких платформах?

Здравствуйте, Кодт, Вы писали:

E>>Например, как всё-таки вычислить корректно разность двух unsigned чисел, ессли больше может быть любое?

К>Ты не понял!
К>С арифметикой по модулю она справляется.
К>А с человеческой — честно реализует undefined behavior, как и просил Максим. Или ты хочешь, чтобы UB всегда форматировало диск?

Да знаю я с чем и как она справляется.

Вот у меня есть две положительные величины. Те жа самые пять апельсинов у тебя и три у меня.
Я хочу уметь вычислить разность. Ну типа "на сколько у меня больше"
При этом я вовсе не хочу получить 0xFFFFFFFE а хочу получить -2. Правда извращённое желание?

Здравствуйте, Vain, Вы писали:

V>

V>#ifdef _DEBUG
V>typedef int MYLIB_SIZE;
V>#else
V>typedef unsigned int MYLIB_SIZE;
V>#endif
V>

Прекрасный, надёжный способ сделать неотлаживаемую программу, которая в релизе и дебаге гарантированно ведёт себя по-разному!!!

Не поделишься зачем это надо?

Народ!
Для людей, которым так нравится слово unsigned написанное не в комментарии к методу, а в имени типа возвращаемого значения я предлагаю поступать так:

typedef int int_for_unsigned_values;

И читабельно всё станет и совместимо и вообще со всех сторон прекрасно.

Для совсем уж пуристов его можно сделать не typedef, а enum со своими операторами. Скажем так:

enum int_for_unsigned_values{ int_for_unsigned_values_min = INT_MIN, int_for_unsigned_values_max = INT_MAX };
inline int_for_unsigned_values opearator + ( int_for_unsigned_values left, int_for_unsigned_values right )
{
    return static_cast<int_for_unsigned_values>( left + right);
}

Ну и т. д.

Можно даже assert'ом проверять, что всё было и осталось положительным.

и будет всем счастье