Почему переменные без знака используются чаще? [Дубликат]

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

Во всяком случае, что вы думаете по этому поводу?

Дублированный

Почему Array Length является Int, а не UInt?

29.01.2009 01:51:50
Michael Haren 29.01.2009 01:56:06
Мне нравится ваша идея о том, чтобы заставить неотрицательные числа использовать uint. Взгляните на spec # (экспериментальный) - полезный материал для контрактного программирования. research.microsoft.com/en-us/projects/specsharp
Michael Haren 29.01.2009 01:58:14
Уххй. Хорошие ответы на первый вопрос о соответствии без CLS. Вот почему просмотр комментариев стоит времени.
Leonidas 29.01.2009 02:05:08
Я думаю, что критерии для дублированного статуса слишком свободны. Эта ссылка похожа, но точно не является точной копией. Просто мои 2 цента. Я думаю, что я буду в порядке.
Alex Baranosky 29.01.2009 03:39:10
12 ОТВЕТОВ
РЕШЕНИЕ

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

4
29.01.2009 01:55:23

Тебе не нужно делать это вручную, я не думаю.

В любом случае, это потому, что для большинства приложений это не имеет значения - диапазон для обоих достаточно большой для большинства применений.

-1
29.01.2009 01:54:58
В любом случае требуется явное приведение. Вы в некотором смысле сужаете любое направление, потому что окно смещено.
Michael Haren 29.01.2009 02:00:42
Ack! Я просто удалил чей-то комментарий случайно. Сожалею!
Michael Haren 29.01.2009 02:01:30
да, явное приведение необходимо. Он говорит: «не может неявно преобразовать« long »в« int »
Alex Baranosky 29.01.2009 03:36:41

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

1
29.01.2009 01:57:05

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

  • int - это «стандарт» или «по умолчанию», за ним много инерции.
  • Вы должны использовать раздражающие / уродливые явные приведения повсюду, чтобы вернуться к int, который вам, вероятно, понадобится сделать в связи с первым пунктом.
  • Когда вы выполняете приведение обратно к int, что произойдет, если ваше значение uint переполнит его?
  • Чаще всего люди используют целые числа для вещей, которые никогда не бывают отрицательными, а затем используют -1 или -99 или что-то подобное для кодов ошибок или неинициализированных значений. Возможно, это немного лениво, но опять же, это то, с чем уинт менее гибок.
0
29.01.2009 02:00:49

Идея, что unsigned предотвратит вас от проблем с методами / членами, которые не должны иметь дело с отрицательными значениями, несколько ошибочна:

  • теперь вы должны проверить большие значения («переполнение») в случае ошибки
    • тогда как вы могли бы проверить на <= 0 со знаком
  • используйте только один подписанный int в своих методах, и вы вернетесь к квадрату со знаком :)

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

6
29.01.2009 02:00:57

Я не могу точно вспомнить, как C # выполняет неявные преобразования, но в C ++ расширяющие преобразования выполняются неявно. Без знака считается шире, чем со знаком, и это приводит к неожиданным проблемам:

int s = 5;
unsigned int u = 25;
// s > u is false

int s = -1;
unsigned int u = 25;
// s > u is **TRUE**! Error error!

В приведенном выше примере s переполнен, поэтому его значение будет примерно таким: 4294967295. Это вызывало у меня проблемы раньше, у меня часто бывают методы, возвращающие -1, чтобы сказать «нет совпадения» или что-то в этом роде, и при неявном преобразовании это просто не удается делать то, что я думаю, должно.

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

3
29.01.2009 02:01:37
в C # вы должны разыграть его вручную
Alex Baranosky 29.01.2009 03:41:13

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

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

0
29.01.2009 02:02:20

Одна из причин заключается в том, что открытые методы или свойства, ссылающиеся на неподписанные типы, не соответствуют CLS.

Вы почти всегда увидите, как этот атрибут применяется к сборкам .Net, так как различные мастера включают его по умолчанию:

[сборка: CLSCompliant (правда)]

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

3
29.01.2009 02:04:21

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

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

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

2
29.01.2009 02:12:56

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

2
29.01.2009 02:10:09

Не рекомендуется использовать целое число без знака, потому что, если вы присвоили ему отрицательные значения, все прервутся к черту. Однако, если вы настаиваете на том, чтобы делать это правильно, попробуйте использовать Spec #, объявите его как целое число (где вы бы использовали uint) и прикрепите к нему инвариант, говоря, что он никогда не может быть отрицательным.

1
29.01.2009 02:18:47

Это потому, что они не совместимы с CLS, что означает, что ваш код может работать не так, как вы ожидаете в других реализациях платформы .NET или даже в других языках .NET (если не поддерживается).

Также он не совместим с другими системами, если вы попытаетесь их пропустить. Например, веб-сервис для Java или вызов Win32 API.

Посмотрите, что ТАК сообщение о причине, а также

-1
23.05.2017 11:59:28
-1: для взаимодействия. комментарий, особенно веб-сервисы (которые обмениваются данными в строковой форме, поэтому подписанные / неподписанные (не напрямую) не учитываются).
Lawrence Dol 29.01.2009 02:35:03