Целочисленное ли целое число используется как тип данных?

Используют ли большинство разработчиков приложений целые числа со знаком в тех местах, где они действительно хотят использовать целые числа без знака? Я делаю это все время, как и мои коллеги. Я не видел много других обширных кодовых баз (кроме Delphi VCL), и примеры в Интернете обычно используют целочисленные значения. Принимая во внимание, что разработчики VCL используют свои собственные типы данных (что было бы наиболее ленивым способом объявления переменных).

Что-то кажется немного ужасным в таком коде

TStuffRec = record
   recordID : Integer;
   thingID : Integer;
   otherThingID : Integer;
end;

когда это может быть написано как

TStuffRec = record
   recordID : Cardinal;
   thingID : Cardinal;
   otherThingID : Cardinal;
end;

Функционально эти записи почти всегда работают одинаково (и, надеюсь, продолжат работать одинаково даже в 64-битной Delphi). Но очень большие числа будут иметь проблемы с конверсией.

Но есть и недостатки использования неподписанных целых. Главным образом проистекает из того, как раздражает смешивать два.

На самом деле вопрос в том, действительно ли об этом думают или включают в лучшие практики? Обычно это зависит только от разработчика?

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

for i := 0 to List.Count - 1 do
  //do something here

Я iобъявил как целое число без знака (в конце концов, это индекс в списке, который начинается с 0, он никогда не должен быть отрицательным, верно?), Но когда он List.Countбыл равен 0, он не будет замыкать цикл, как ожидалось, потому что 0 - 1оценивает очень высокое положительное число. К сожалению!

Между потенциальными проблемами безопасности, присущими смешиванию целых чисел со знаком и без знака, и проблемами диапазона (если вам понадобятся положительные числа, большие чем high(signed whatever), вполне вероятно, что вам также понадобятся положительные числа, большие , чем high(unsigned whatever)тоже, поэтому переходите до следующего большего размера вместо того, чтобы переключаться со знака на без знака того же размера, обычно правильное действие,) я действительно не нашел слишком много применений для целых чисел без знака при представлении большинства данных.

Честно говоря, я склонен использовать целые числа по привычке. Я привык к тому, что они предлагают достаточно большие диапазоны для большинства ситуаций и допускают отрицательные значения (например, -1). Действительно, много раз использование байтов / word / shortint было бы более уместным. Теперь, думая об этом, я могу сосредоточиться на следующих местах:

• Perspective. Размер карты тайлов ограничен 192x192 тайлами, поэтому я могу использовать байт для адресации тайлов и циклов. Но если размер карты будет увеличен, мне придётся проходить каждое использование и заменять его, например, словом. Когда мне нужно разрешить объекты вне карты, мне нужно будет снова перейти на smallint.

• Loops. Часто я пишу цикл «от i: = 0 до Count-1», что происходит, если «i» - байт, а Count = 0 - цикл выполняется от 0 до 255. Не то, чтобы я этого хотел.

• Унифицируйся. Проще запомнить и применить «var i: integer;» чем останавливаться в каждом случае и думать: «Хм .. здесь мы имеем дело с диапазоном 0..120 .. байт .. нет, подождите, нам может понадобиться -1 для неинициализированной .. краткости .. подождите .. что если 128 не достаточно .. Arrgh! " или "Почему в этом месте smallint, а не shortint?"

• Объединение. Когда мне нужно объединить два или более классов вместе, они могут использовать разные типы данных для своих целей, использование более широких типов позволяет пропустить ненужные преобразования.

• -1. Даже когда значения находятся в диапазоне 0..n-1, мне часто нужно устанавливать значение «нет значения / неизвестно / неинициализировано / пусто», что по общепринятой практике -1.

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

PS Когда я использую другие типы?

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

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

Примеры C #: если бы мне нужно было поддерживать только от 0 до 255, я бы использовал байт.

Если мне нужно было поддержать 1000000 негатива и позитива, тогда int.

Больше, чем 4,2 миллиарда, а затем использовать длинный.

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

Вот ссылка на C # int из MSDN.

int 
 -2,147,483,648 to 2,147,483,647
 Signed 32-bit integer

uint 
 0 to 4,294,967,295
 Unsigned 32-bit integer

long 
 -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
 Signed 64-bit integer

ulong 
 0 to 18,446,744,073,709,551,615
 Unsigned 64-bit integer

Целочисленные типы без знака должны использоваться только для представления кардинальных чисел в языках, где они представляют кардинальные числа. Из-за того, что компьютеры, работающие на C, работали, целочисленные типы без знака вели себя как члены алгебраических колец mod-2 ^ n (означая, что переполненные вычисления предсказуемо «обертывают»), а язык указывает, что во многих случаях такие типы требуется вести себя как абстрактные алгебраические кольца, даже если такое поведение будет несовместимо с поведением кардинальных чисел или математических чисел.

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

Однако, учитывая относительное отсутствие типов кардинальных чисел, лучше всего просто использовать целые числа для представления математических и кардинальных чисел.