Является ли int 64-разрядным целым числом в 64-битном С#?

Ответ 1

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

Ответ 2

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

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

• System.Int32 - Подписанное 32-битное целое число

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

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

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

Ответ 3

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

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

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

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

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

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

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

Ответ 4

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

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

Ответ 5

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

Ответ 6

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

Ответ 7

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

Ответ 8

Следующее будет всегда быть правдой в С#:

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

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

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

ushort неподписанные 16 бит, 2 байта

int подписан 32 бита, 4 байта

uint unsigned 32 bits, 4 байта

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

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

Integer литерал - это просто последовательность цифр (например, 314159) без каких-либо из этих явных типов. С# присваивает ему первый тип в последовательности (int, uint, long, ulong), в котором он подходит, Это, по-видимому, слегка запуталось, по крайней мере, в одном из ответов выше.

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

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

Ответ 9

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

Ответ 10

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

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

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

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