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

Question

В моем исходном коде на C # я мог объявить целые числа как:

int i = 5;

или

Int32 i = 5;

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

int i = 5;
Int64 i = 5;

Answer 1

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

Answer 2

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

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

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

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

• int - 32-разрядный целочисленный тип со знаком

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

Answer 3

Будет ли 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 меняет свой размер на разных архитектурах.

Answer 4

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

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

Answer 5

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

Answer 6

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

Answer 7

Следующее всегда будет истинным в C #:

sbyte 8 бит со знаком, 1 байт

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

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

ushort 16 бит без знака, 2 байта

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

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

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

ulong без знака 64 бита, 8 байтов

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

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

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

Answer 8

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

Answer 9

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

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

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

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

Answer 10

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