В моем исходном коде С# я мог объявить целые числа как:
int i = 5;
или
Int32 i = 5;
В распространенном в настоящее время 32-битном мире они эквивалентны. Однако, когда мы переходим в 64-битный мир, могу ли я сказать, что следующее станет таким же?
int i = 5;
Int64 i = 5;
Нет. Спецификация С# жестко определяет, что int является псевдонимом для System.Int32 с ровно 32 битами. Изменение этого было бы серьезным нарушением.
Ключевое слово int в С# определяется как псевдоним для типа System.Int32, и это (судя по имени) означает 32-разрядное целое число. К спецификации:
спецификация CLI в разделе 8.2.2 (встроенное значение и ссылочные типы) имеет таблицу со следующим:
System.Int32- Подписанное 32-битное целое числоспецификация С# в разделе 8.2.1 (предопределенные типы) имеет аналогичную таблицу:
int- 32-битный подписанный интегральный тип
Это гарантирует, что как System.Int32 в CLR, так и int в С# всегда будет 32-разрядным.
Будет ли 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 изменяет свой размер на разных архитектурах.
int всегда является синонимом Int32 на всех платформах.
Очень маловероятно, что Microsoft изменит это в будущем, так как это сломает много существующего кода, который предполагает, что int - 32 бит.
Я думаю, что вы можете быть смущены тем, что int является псевдонимом для Int32, поэтому он всегда будет 4 байта, но IntPtr должен соответствовать размеру слова архитектуры процессора, чтобы он был 4 байта в 32-битной системе и 8 байтов в 64-битной системе.
В соответствии со спецификацией С# ECMA-334, раздел "11.1.4 Простые типы", зарезервированное слово int будет сфальсифицировано до System.Int32. Поскольку это в спецификации, это вряд ли изменится.
Независимо от того, используете ли вы 32-разрядную версию или 64-разрядную версию CLR, в С# a int всегда будет означать System.Int32, а long всегда будет означать System.Int64.
Следующее будет всегда быть правдой в С#:
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 или что-то в этом роде.
Да, как сказал Джон, и в отличие от "C/С++ world", Java и С# не зависят от системы, в которой они работают. Они имеют строго определенные длины для байтов/коротких/int/long и одиночных/двойных прецизионных поплавков, равных для каждой системы.
int без суффикса может быть либо 32-битным, либо 64-битным, это зависит от значения, которое оно представляет.
как определено в MSDN:
Когда целочисленный литерал не имеет суффикса, его тип является первым из этих типов, в котором его значение может быть представлено: int, uint, long, ulong.
Вот адрес: https://msdn.microsoft.com/en-us/library/5kzh1b5w.aspx