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

N>тут натуральность — это частный случай. А ожидается именно целое оложительное.

Это уже абстрактная философия. Если на бумаге записаны числа 1, 2, 3 и т.п., то для них справедливы утверждения: "числа являются целыми", "числа являются натуральными". Что меняется от того, что те же самые числа записаны в память компьютера с аналогичной их интерпретацией в языке?

N>Потому что код не будет работать без явного каста к целому.

Так это ж хорошо. Радиус — это количество клеток/пикселов (объектов реального мира), так что его значение, по своей сути, может быть только натуральным. А когда Вы хотите отложить это количество на координатной сетке влево от нуля, происходит переход к отрицательным целым. Значение радиуса и значения переменной, пробегающей интервал от -r до r, имеют различный смысл, хоть они временами и равны численно и/или визуально схожи. Явное преобразование это и подчеркивает, и поясняет.

N>Все размеры изображений знаковые, потому что они тоже могут стать отрицательными в результате преобразований — корректных преобразований.

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

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

TB>https://channel9.msdn.com/Events/GoingNative/2013/Interactive-Panel-Ask-Us-Anything
TB>Страуструп называет беззнаковые типы опасными

Апелляция к авторитету?

TB>

TB>Whenever you mix signed and unsigned numbers you get trouble. The rules are just very surprising, and they turn up in code in strange places that correlate very strongly with bugs. Now, when people use unsigned numbers they usually have a reason. And the reason will be something like 'well, it can't be negative' or 'I need an extra bit'. If you need an extra bit, I am very reluctant to believe that you really need it, and I don't think that's a good reason. When you think you can't have negative numbers, you will have somebody who initializes your unsigned with minus two, and think they get minus two, and things like that.

TB>It is just highly error prone.

TB>I think one of the sad thing about the standard library is that the indices are unsigned whereas array indices are signed and you are sort of doomed to have confusion, and problems with that. There are far too many integer types, there are far too lenient rules for mixing them together, and it's a major bug source, which is why I'm saying stay as simple as you can, use [signed] integers till you really really need something else.

Страуструп, конечно, лютый красавчик, но в этом высказывании он не смог обосновать "необходимость использования именно знаковых". Этот его совет — для массы зеленой молодежи, не более. Это классика кун-фу:

На вопрос учеников: "как добиться гармонии?", ты говоришь: "никогда не делайте то-то".

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

V>Страуструп, конечно, лютый красавчик, но в этом высказывании он не смог обосновать "необходимость использования именно знаковых". Этот его совет — для массы зеленой молодежи, не более.

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

Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>Это уже абстрактная философия. Если на бумаге записаны числа 1, 2, 3 и т.п., то для них справедливы утверждения: "числа являются целыми", "числа являются натуральными". Что меняется от того, что те же самые числа записаны в память компьютера с аналогичной их интерпретацией в языке?

Это не абстрактная философия, а вполне конкретная практика. Если мне надо числа вычитать и брать противоположный элемент, то я выберу signed. Если ввести можно только положительное число, то проверю его один раз на корректность. Вот и всё. Я просто делаю проверку при вводе значения, а дальше использую его как целое безо всяких побочных эффектов.
Альтернатива этому подходу: также проверять число при вводе (потому что какие-нибудь ограничения всегда есть, например на максимально значение), а потом каждый раз при вычитании либо кастую к знаковому, либо добавляю дополнительные условия на больше/меньше.
Тут именно незамкнутость натуральных чисел относительно вычитания имеет принципиальное значение. Как бы ты мне не повторял, что натуральные — это подмножество целых, но на практике от этого не легче и надо работать в целых, чтобы жизнь не превратилась в кошмар

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

MA>Здравствуйте, Alexander G, Вы писали:


AG>>- fused операция при сравнении и переходе: while (i > 0) или for ( i ; i < 10 ; i++ ) CMP и JCC выполняются как одна операция только для беззнаковых.

MA> Это не так и при чем уже довольно давно.

Intel Optimization Reference Manual, September 2019

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

AG>>>- fused операция при сравнении и переходе: while (i > 0) или for ( i ; i < 10 ; i++ ) CMP и JCC выполняются как одна операция только для беззнаковых.
MA>> Это не так и при чем уже довольно давно.
AG>Intel Optimization Reference Manual, September 2019
Именно там эту информацию и можно найти. И в более старых мануалах тоже например.

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

TB>Ну допустим, что i++ в середине выражения ещё можно считать стандартной практикой, если i больше нигде в выражении не используется.
TB>А какие-нибудь c=a+=b уже точно нафиг.

А как же классическое K&R-style

*dst++ = *src--;

Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>Если так, то что обозначает 0-1 = -1, какой смысл несет это значение?

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

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

TB>Там --i. То есть число уменьшаем до тех пор, пока оно не станет очень большим. Неестественно.

С фига ли неестественно? Это же кольцо?

Здравствуйте, Евгений Музыченко, Вы писали:

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

1) Они не делят. Ещё бывают неотрицательные целые, простые, чётные... У всех этих подмножеств есть свои особенности. Например, для натуральных, начиная с двойки, верна основная теорема арифметики, все эти вод разложения на простые, делимости и т. д. Но даже и в арифметике, стоит только дойти до Диофантовых уравнений, как отрицательные целые снова появляются в полный рост...

2) С-шные unsigned типы -- это не целые. Это кольцо по модулю вычетов. Почему тебе кажется более естественным нумеровать элементы последовательности элементами такого кольца, а не ограниченными по модулю целыми числами, для меня загадка...

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

R>Как только я их выдержал, требования тут же изменились. Ну просто упрямствуешь же.
Он, похоже, про другое ограничение.
Оно, кстати, не такое уж и вздорное, и относительно популярно в разных стилях кодирования.
Ограничение такое -- нельзя менять параметр цикла for, где-то кроме третей части заголовка цикла. Хочешь итерировать как-то нетривиально -- используй while. Читатель твоего кода поймёт, что тут это всё не спроста, и не прозевает i++ где-то в недрах тела цикла.
Ну, во всяком случае такая логика в теории


TB>>Вообще то, как яро вы отстаиваете подобную запись, и есть аргумент против беззнаковых.
R>Странная логика. А то, как яро ты оспариваешь эту запись является аргументом против знаковых что ли?

У коллеги вообще логика мне не понятная.
На мой взгляд,

unsigned int -- это кольцо по модуля вычетов
signed int -- это целые, ограниченные по модулю (ну, если совсем точно, то чуть несимметричный интервал, но это в любом случае целые INT_MIN <= z <= INT_MAX)

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

Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>Индекс массива в C/C++ не может быть отрицательным — это следует из определения массива. То, что подобные операции могут приводить к отрицательным смещениям, ничем не отличается от технической возможности обратиться к элементу с очень большим индексом, чтобы за счет переполнения попасть раньше начала массива. Тут просто нужно различать техническую возможность получить какой-то результат, и смысл применямой операции.

Ну мы же можем индексировать и отрезок последовательности? Вот есть у меня подпоследовательность. Почему бессмысленно ссылаться на "элемент, предшествующий первому элементу нашей подпоседовательности"?

Вот нумеровать последовательности с 0 (особенно, если считать, что отрицательных индексов не бывает) -- это вот да, противоестественно...

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

V>Бритва Окама, вестимо. В ситуации где использование знака не является необходимым — использовать без-знаковые типы.

Ударим бритвой Оккама буриданову ослу прямо по яйцам!!!

На мой взгляд в конструкции "Надо нумеровать члены последовательности" + "целое число из диапазона [INT_MIN, INT_MAX]" + "кольцо модулей по вычетам какой-то неизвестной степени двойки" лишнее-то, как раз, кольцо...

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

E>Оно, кстати, не такое уж и вздорное, и относительно популярно в разных стилях кодирования.
E>Ограничение такое -- нельзя менять параметр цикла for, где-то кроме третей части заголовка цикла. Хочешь итерировать как-то нетривиально -- используй while. Читатель твоего кода поймёт, что тут это всё не спроста, и не прозевает i++ где-то в недрах тела цикла.
E>Ну, во всяком случае такая логика в теории

а если внутри ерэйс нужен, на while переделывать?
странное какое-то правило.

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

E>А как же классическое K&R-style

*dst++ = *src--;

Ага, и всё это внутри одного while()
Классика говнокода.

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

V>>Бритва Окама, вестимо. В ситуации где использование знака не является необходимым — использовать без-знаковые типы.

E>Ударим бритвой Оккама буриданову ослу прямо по яйцам!!!

E>На мой взгляд в конструкции "Надо нумеровать члены последовательности" + "целое число из диапазона [INT_MIN, INT_MAX]" + "кольцо модулей по вычетам какой-то неизвестной степени двойки" лишнее-то, как раз кольцо...

А почему именно [INT_MIN, INT_MAX], именно int? Почему не [SHRT_MIN, SHRT_MAX] и не [PTRDIFF_MIN, PTRDIFF_MAX]? Вот ты хитришь. У себя взял и преподнес определенность размера как "INT", а кольцо модулей снабдил характеристикой "... какой-то неизвестной степени двойки".

Еще вопрос, почему акцент делается на то что беззнаковые — это именно кольцо модулей по вычетам? Что такого плохого в кольцах, что по ним надо бритвой ударять? Ну, кольцо, ну и пусть, ведь в оригинальном вопросе ТС не про кольцо а про бесполезность знака для таких штук как:

счетчики, индексы и прочие... размеров, количеств и прочего...

И последний: если бы int тоже был бы закольцован, то есть при переполнении просто бы отбрасывались переполненные биты, как, например, в Расте — ты все равно бы знаковым отдал предпочтение?

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

E>>А как же классическое K&R-style

*dst++ = *src--;

TB>Ага, и всё это внутри одного while()
Ну ты это, книжку с большой и синей буквой "С" читал?..

TB>Классика говнокода.
Я бы одно слово из фразы выше викинул

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

E>Ну ты это, книжку с большой и синей буквой "С" читал?..

Дак это и есть пример из неё: копирование строки:

while(*dst++=*src++);

Говнокод говнокодом.

TB>>Классика говнокода.
E>Я бы одно слово из фразы выше викинул

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

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

V>А почему именно [INT_MIN, INT_MAX], именно int? Почему не [SHRT_MIN, SHRT_MAX] и не [PTRDIFF_MIN, PTRDIFF_MAX]? Вот ты хитришь. У себя взял и преподнес определенность размера как "INT", а кольцо модулей снабдил характеристикой "... какой-то неизвестной степени двойки".

Потому, что при обычном использовании int вместо чисел, не важно чему равно INT_MIN и INT_MAX. Важно, что это какая-то не особо известная, но достаточно большая константа.
Если важно, тогда надо выбрать правильный тип в любом случае.
А с беззнаковыми эта "неизвестная, но достаточно большая константа" становится актуальной при любом вычитании

PTRDIFF_MIN -- вообще странно использовать как просто число. Это же специальный тип, для специальных целей...

V>Еще вопрос, почему акцент делается на то что беззнаковые — это именно кольцо модулей по вычетам? Что такого плохого в кольцах, что по ним надо бритвой ударять? Ну, кольцо, ну и пусть, ведь в оригинальном вопросе ТС не про кольцо а про бесполезность знака для таких штук как:

Ну так я просто указал ЧТО КОНКРЕТНО реализуют знаковые и беззнаковые в С...
Ты можешь поверх этих моделей натянуть какие-то свои. В С, например, выражение 1 < 2 будет иметь тип int, то есть знаковое целое.

V>

V>счетчики, индексы и прочие... размеров, количеств и прочего...

Естественный взгляд на размер последовательности -- разность позиций краёв. Странно считать, что там модули по вычету логичнее, чем отрезок целочисленного ряда

V>И последний: если бы int тоже был бы закольцован, то есть при переполнении просто бы отбрасывались переполненные биты, как, например, в Расте — ты все равно бы знаковым отдал предпочтение?

Конечно. За исключением логики оптимизатора, int и так на x86 закольцован

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

Обсуждаемый тезис, про количества с индексами предполагает, что беззнаковые -- это как бы подмножество целых. А это не так. Они не подмножества, а просто другие. Так вышло по историческим причинам. Увы, но таки так вышло.

Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>Даже во многих современных программах на C++ часто вижу int/short/long там, где по смыслу должно быть беззнаковое целое. А в ранних программах знаковые целые вообще использовались везде, где было технически возможно. Даже в классической книге Кернигана/Ритчи множество примеров, где счетчики, индексы и прочие имеют знаковый тип. В виндовых SDK, где знаковость в основном используется адекватно, все равно регулярно встречаются знаковые параметры размеров, количеств и прочего, где не используются отрицательные значения для особых случаев.

ЕМ>Откуда такое пристрастие, кроме как от лени? Вроде как сколько-нибудь массовых процессоров, где беззнаковые целые поддерживались бы ограниченно, не существует. Есть в этом хоть какое-то рациональное зерно?

В прошлом помнится нередко возникали траблы, когда переменная "случайно" уходила в область отрицательных значений и, будучи unsigned, превращалась в очень большое полож число, нарушая логику. Туда же и ==/!= в циклах вместо > <. С тех пор завел правило всегда юзать signed into, кроме случаев, когда нужно уместить большое число, которое не умещается в signed. В остальных случаях Unsigned не дают никакого выигрыша -Только писать больше приходится.