Является ли int 64-битным целым числом в 64-битном C #?

StackOverflow https://stackoverflow.com/questions/164643

  •  03-07-2019
  •  | 
  •  

Вопрос

В моем исходном коде C # я, возможно, объявил целые числа как:

int i = 5;

или

Int32 i = 5;

В распространенном в настоящее время 32-разрядном мире они эквивалентны.Однако, поскольку мы переходим в 64-битный мир, правильно ли я говорю, что следующее станет таким же?

int i = 5;
Int64 i = 5;
Это было полезно?

Решение

Нет.Спецификация C # жестко определяет, что int является псевдонимом для System.Int32 ровно с 32 битами.Изменение этого было бы майор решающая перемена.

Другие советы

В int ключевое слово в C # определяется как псевдоним для System.Int32 введите, и это (судя по названию) должно быть 32-разрядным целым числом.В соответствии со спецификацией:

Спецификация CLI раздел 8.2.2 (Встроенные типы значений и ссылок) содержит таблицу со следующим:

  • System.Int32 - 32-разрядное целое число со знаком

Спецификация C# раздел 8.2.1 (Предопределенные типы) содержит аналогичную таблицу:

  • int - 32-разрядный подписанный интегральный тип

Это гарантирует, что оба System.Int32 в CLR и int в C # всегда будет 32-разрядный.

Будет ли sizeof (testInt) когда-нибудь равен 8?

Нет, sizeof(testInt) - это ошибка.testInt - это локальная переменная.Оператор sizeof требует, чтобы в качестве аргумента был указан тип.Это никогда не будет 8, потому что это всегда будет ошибкой.

VS2010 компилирует управляемое c # целое число в виде 4 байт даже на 64-разрядной машине.

Правильно.Я отмечаю, что раздел 18.5.8 спецификации C # определяет sizeof(int) как константа времени компиляции 4.То есть, когда вы говорите sizeof(int) компилятор просто заменяет это на 4;это точно так же, как если бы вы сказали "4" в исходном коде.

Кто-нибудь знает, придет ли / когда время, когда стандартный "int" в C # будет 64-битным?

Никогда.В разделе 4.1.4 спецификации C # указано, что "int" является синонимом "System.Int32".

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

int всегда является синонимом Int32 на всех платформах.

Маловероятно, что Microsoft изменит это в будущем, поскольку это нарушило бы многие существующие коды, которые предполагают int является 32-битным.

Я думаю, что вас может смутить то, что int является псевдонимом для Int32 таким образом, это всегда будет 4 байта, но IntPtr предполагается, что размер слова соответствует архитектуре процессора, поэтому он будет составлять 4 байта в 32-разрядной системе и 8 байт в 64-разрядной системе.

В соответствии со спецификацией C # ECMA-334, раздел "11.1.4 Простые типы", зарезервированное слово int будет присвоен псевдоним System.Int32.Поскольку это указано в спецификации, маловероятно, что это изменится.

Независимо от того, используете ли вы 32-разрядную или 64-разрядную версию среды CLR, в C # int всегда будет означать System.Int32 и long всегда будет означать System.Int64.

Следующее будет всегда будь верен в C#:

сбайт подписанные 8 бит, 1 байт

байт 8 бит без знака, 1 байт

короткий подписанный 16 бит, 2 байта

сопровождающий 16 бит без знака, 2 байта

инт 32 бита со знаком, 4 байта

uint 32 бита без знака, 4 байта

длинный подписанный 64 бита, 8 байт

улонг 64 бита без знака, 8 байт

Целое число буквальный это просто последовательность цифр (например 314159) без любой из этих явных типов.C # присваивает ему первый тип в последовательности (инт, uint, длинный, улонг), в который это вписывается.Похоже, это было немного запутано по крайней мере в одном из приведенных выше ответов.

Странно в оператор унарного минуса (знак минус) отображается до того, как строка цифр не сократите выбор до (инт, длинный).Буквальное значение всегда позитивно;знак минус на самом деле является оператором.Так что предположительно -314159 является именно так то же самое , что и -((int)314159).За исключением того, что, очевидно, есть особый случай, который нужно получить -2147483648 прямо в инт;в противном случае это было бы -((uint)2147483648).Который, я полагаю, делает что-то неприятное.

Почему-то кажется безопасным предсказать, что C # (и друзья) никогда не будут беспокоиться о типах "мягкого имени" для целых чисел >= 128 бит.Мы получим хорошую поддержку для произвольно большие целые числа и сверхточная поддержка UInt128, UInt256 и т.д.как только процессоры будут поддерживать выполнение математики в таком широком масштабе и вряд ли когда-либо будут использовать что-либо из этого.64-разрядные адресные пространства представляют собой действительно большой.Если они когда-нибудь окажутся слишком маленькими, это будет по какой-то эзотерической причине, такой как ASLR или более эффективный MapReduce или что-то в этом роде.

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

int без суффикса может быть либо 32-битным, либо 64-битным, это зависит от значения, которое он представляет.

как определено в MSDN:

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

Вот этот адрес:https://msdn.microsoft.com/en-us/library/5kzh1b5w.aspx

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top