Содержание

Тип данных Integer — Visual Basic

  • Чтение занимает 2 мин

В этой статье

Содержит 32-разрядные (4-байтовые) целые числа со знаком в диапазоне от -2 147 483 648 до 2 147 483 647.Holds signed 32-bit (4-byte) integers that range in value from -2,147,483,648 through 2,147,483,647.

КомментарииRemarks

Тип данных Integer обеспечивает оптимальную производительность на 32-разрядных процессорах.The Integer data type provides optimal performance on a 32-bit processor. Другие целочисленные типы загружаются в память и сохраняются в памяти с более низкой скоростью.The other integral types are slower to load and store from and to memory.

Значение по умолчанию для типа

Integer — 0.The default value of Integer is 0.

Присваивания литераловLiteral assignments

Вы можете объявить и инициализировать Integer переменную, назначив ей десятичный литерал, шестнадцатеричный литерал, Восьмеричный литерал или (начиная с Visual Basic 2017) двоичный литерал.You can declare and initialize an Integer variable by assigning it a decimal literal, a hexadecimal literal, an octal literal, or (starting with Visual Basic 2017) a binary literal. Если целочисленный литерал выходит за пределы диапазона Integer (то есть, если он меньше Int32.MinValue или больше Int32.MaxValue), возникает ошибка компиляции.If the integer literal is outside the range of Integer (that is, if it is less than Int32.MinValue or greater than Int32.MaxValue, a compilation error occurs.

В следующем примере целые числа, равные 90 946 и представленные в виде десятичного, шестнадцатеричного и двоичного литерала, назначаются значениям

Integer.In the following example, integers equal to 90,946 that are represented as decimal, hexadecimal, and binary literals are assigned to Integer values.

Dim intValue1 As Integer = 90946
Console.WriteLine(intValue1)
Dim intValue2 As Integer = &h26342
Console.WriteLine(intValue2)

Dim intValue3 As Integer = &B0001_0110_0011_0100_0010
Console.WriteLine(intValue3)
' The example displays the following output:
'          90946
'          90946
'          90946

Примечание

Используйте префикс &h или &H , чтобы обозначить шестнадцатеричный литерал, префикс &b или &B обозначить двоичный литерал, а также префикс &o или &O обозначить Восьмеричный литерал.You use the prefix

&h or &H to denote a hexadecimal literal, the prefix &b or &B to denote a binary literal, and the prefix &o or &O to denote an octal literal. У десятичных литералов префиксов нет.Decimal literals have no prefix.

Начиная с Visual Basic 2017, можно также использовать символ подчеркивания () в _ качестве разделителя цифр, чтобы улучшить удобочитаемость, как показано в следующем примере.Starting with Visual Basic 2017, you can also use the underscore character, _, as a digit separator to enhance readability, as the following example shows.

Dim intValue1 As Integer = 90_946
Console.WriteLine(intValue1)

Dim intValue2 As Integer = &H0001_6342
Console.WriteLine(intValue2)

Dim intValue3 As Integer = &B0001_0110_0011_0100_0010
Console.WriteLine(intValue3)
' The example displays the following output:
'          90946
'          90946
'          90946

Начиная с Visual Basic 15,5, можно также использовать символ подчеркивания () в _ качестве начального разделителя между префиксом и шестнадцатеричными, двоичными или восьмеричными цифрами.Starting with Visual Basic 15.5, you can also use the underscore character (_) as a leading separator between the prefix and the hexadecimal, binary, or octal digits. Пример:For example:

Dim number As Integer = &H_C305_F860

Чтобы использовать символ подчеркивания в качестве начального разделителя, нужно добавить в файл проекта Visual Basic (*.vbproj) следующий элемент:To use the underscore character as a leading separator, you must add the following element to your Visual Basic project (*.vbproj) file:

<PropertyGroup>
  <LangVersion>15.5</LangVersion>
</PropertyGroup>

Для получения дополнительной информации см.For more information see setting the Visual Basic language version.

Числовые литералы также могут включать I символ типа для обозначения Integer типа данных, как показано в следующем примере.Numeric literals can also include the I type character to denote the Integer data type, as the following example shows.

Dim number = &H_035826I

Советы по программированиюProgramming tips

  • Вопросы взаимодействия.Interop Considerations. При взаимоработе с компонентами, которые не записываются для .NET Framework, таких как автоматизация или COM-объекты, помните, что Integer

    в других средах ширина данных (16 бит) отличается.If you are interfacing with components not written for the .NET Framework, such as Automation or COM objects, remember that Integer has a different data width (16 bits) in other environments. При передаче 16-разрядного аргумента такому компоненту в новом коде Visual Basic следует объявить его как Short, а не как Integer.If you are passing a 16-bit argument to such a component, declare it as Short instead of Integer in your new Visual Basic code.

  • Расширяющие.Widening. Тип данных Integer можно расширить до Long, Decimal, Single или Double.The Integer data type widens to Long, Decimal, Single, or Double. Это означает, что тип

    Integer можно преобразовать в любой из этих типов без возникновения ошибки System.OverflowException.This means you can convert Integer to any one of these types without encountering a System.OverflowException error.

  • Символы типа.Type Characters. При добавлении к литералу символа типа литерала I производится принудительное приведение литерала к типу данных Integer.Appending the literal type character I to a literal forces it to the Integer data type. При добавлении символа идентификатора типа % к любому идентификатору производится принудительное приведение этого идентификатора к типу Integer.Appending the identifier type character % to any identifier forces it to Integer.

  • Тип Framework.Framework Type.

    В .NET Framework данный тип соответствует структуре System.Int32.The corresponding type in the .NET Framework is the System.Int32 structure.

ДиапазонRange

При попытке присвоить целочисленной переменной значение, лежащее за пределами диапазона данного типа, возникает ошибка.If you try to set a variable of an integral type to a number outside the range for that type, an error occurs. При попытке задать дробное значение оно округляется вверх или вниз до ближайшего целого значения.If you try to set it to a fraction, the number is rounded up or down to the nearest integer value. Если число находится точно посередине между двумя целыми числами, значение округляется до ближайшего четного целого.If the number is equally close to two integer values, the value is rounded to the nearest even integer. Такое поведение минимизирует ошибки округления, происходящие от постоянного округления среднего значения в одном направлении.This behavior minimizes rounding errors that result from consistently rounding a midpoint value in a single direction. В следующем коде приведены примеры округления.The following code shows examples of rounding.

' The valid range of an Integer variable is -2147483648 through +2147483647.  
Dim k As Integer  
' The following statement causes an error because the value is too large.  
k = 2147483648  
' The following statement sets k to 6.  
k = 5.9  
' The following statement sets k to 4  
k = 4.5  
' The following statement sets k to 6  
' Note, Visual Basic uses banker’s rounding (toward nearest even number)  
k = 5.5  

См. также разделSee also

Целочисленные типы данных в C++: short, int и long | Уроки С++

  Обновл. 9 Июл 2020  | 

На этом уроке мы рассмотрим целочисленные типы данных, их диапазоны значений, операцию деления, а также переполнение: что это такое и примеры.

Целочисленные типы данных

Целочисленный тип данных — это тип, переменные которого могут содержать только целые числа (без дробной части, например: -2, -1, 0, 1, 2). В языке C++ есть 5 основных целочисленных типов, доступных для использования:

Категория Тип Минимальный размер
Символьный тип данных char 1 байт
Целочисленный тип данных short 2 байта
int 2 байта (но чаще всего 4 байта)
long 4 байта
long long 8 байт

Примечание: Тип char — это особый случай: он является как целочисленным, так и символьным типом данных. Об этом детально мы поговорим на одном из следующих уроков.

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

Определение целочисленных переменных

Определение происходит следующим образом:

char c; short int si; // допустимо short s; // предпочтительнее int i; long int li; // допустимо long l; // предпочтительнее long long int lli; // допустимо long long ll; // предпочтительнее

char c;

short int si; // допустимо

short s;      // предпочтительнее

int i;

long int li; // допустимо

long l;      // предпочтительнее

long long int lli; // допустимо

long long ll;      // предпочтительнее

В то время как полные названия short intlong int и long long int могут использоваться, их сокращенные версии (без int) более предпочтительны для использования. К тому же постоянное добавление int затрудняет чтение кода (легко перепутать с именем переменной).

Диапазоны значений и знак целочисленных типов данных

Как вы уже знаете из предыдущего урока, переменная с n-ным количеством бит может хранить 2возможных значений. Но что это за значения? Это значения, которые находятся в диапазоне. Диапазон — это значения от и до, которые может хранить определенный тип данных. Диапазон целочисленной переменной определяется двумя факторами: её размером (измеряется в битах) и её

знаком (который может быть signed или unsigned).

Целочисленный тип signed (со знаком) означает, что переменная может содержать как положительные, так и отрицательные числа. Чтобы объявить переменную как signed, используйте ключевое слово signed:

signed char c; signed short s; signed int i; signed long l; signed long long ll;

signed char c;

signed short s;

signed int i;

signed long l;

signed long long ll;

По умолчанию, ключевое слово signed пишется перед типом данных.

1-байтовая целочисленная переменная со знаком (signed) имеет диапазон значений от -128 до 127, т.е. любое значение от -128 до 127 (включительно) может храниться в ней безопасно.

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

Целочисленный тип unsigned (без знака) может содержать только положительные числа. Чтобы объявить переменную как unsigned, используйте ключевое слово unsigned:

unsigned char c; unsigned short s; unsigned int i; unsigned long l; unsigned long long ll;

unsigned char c;

unsigned short s;

unsigned int i;

unsigned long l;

unsigned long long ll;

1-байтовая целочисленная переменная без знака (unsigned) имеет диапазон значений от 0 до 255.

Обратите внимание, объявление переменной как unsigned означает, что она не сможет содержать отрицательные числа (только положительные).

Теперь, когда вы поняли разницу между signed и unsigned, давайте рассмотрим диапазоны значений разных типов данных:

Размер/Тип Диапазон значений
1 байт signed от -128 до 127
1 байт unsigned от 0 до 255
2 байта signed от -32 768 до 32 767
2 байта unsigned от 0 до 65 535
4 байта signed от -2 147 483 648 до 2 147 483 647
4 байта unsigned от 0 до 4 294 967 295
8 байтов signed от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807
8 байтов unsigned от 0 до 18 446 744 073 709 551 615

Для математиков: Переменная signed с n-ным количеством бит имеет диапазон от -(2n-1) до 2n-1-1. Переменная unsigned с n-ным количеством бит имеет диапазон от 0 до (2n)-1.

Для нематематиков: Используем таблицу 🙂

Начинающие программисты иногда путаются между signed и unsigned переменными. Но есть простой способ запомнить их различия. Чем отличается отрицательное число от положительного? Правильно! Минусом спереди. Если минуса нет, значит число — положительное. Следовательно, целочисленный тип со знаком (signed) означает, что минус может присутствовать, т.е. числа могут быть как положительными, так и отрицательными. Целочисленный тип без знака (unsigned) означает, что минус спереди отсутствует, т.е. числа могут быть только положительными.

Что используется по умолчанию: signed или unsigned?

Так что же произойдет, если мы объявим переменную без указания signed или unsigned?

Категория Тип По умолчанию
Символьный тип данных char signed или unsigned (в большинстве случаев signed)
Целочисленный тип данных short signed
int signed
long signed
long long signed

Все целочисленные типы данных, кроме char, являются signed по умолчанию. Тип char может быть как signed, так и unsigned (но, обычно, signed).

В большинстве случаев ключевое слово signed не пишется (оно и так используется по умолчанию).

Программисты, как правило, избегают использования целочисленных типов unsigned, если в этом нет особой надобности, так как с переменными unsigned ошибок, по статистике, возникает больше, нежели с переменными signed.

Правило: Используйте целочисленные типы signed, вместо unsigned.

Переполнение

Вопрос: «Что произойдет, если мы попытаемся использовать значение, которое находится вне диапазона значений определенного типа данных?». Ответ: «Переполнение».

Переполнение (англ. «overflow») случается при потере бит из-за того, что переменной не было выделено достаточно памяти для их хранения.

На уроке №28 мы говорили о том, что данные хранятся в бинарном (двоичном) формате и каждый бит может иметь только 2 возможных значения (0 или 1). Вот как выглядит диапазон чисел от 0 до 15 в десятичной и двоичной системах:

Десятичная система Двоичная система
0 0
1 1
2 10
3 11
4 100
5 101
6 110
7 111
8 1000
9 1001
10 1010
11 1011
12 1100
13 1101
14 1110
15 1111

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

Примеры переполнения

Рассмотрим переменную unsigned, которая состоит из 4-х бит. Любое из двоичных чисел, перечисленных в таблице выше, поместится внутри этой переменной.

«Но что произойдет, если мы попытаемся присвоить значение, которое занимает больше 4-х бит?». Правильно! Переполнение. Наша переменная будет хранить только 4 наименее значимых (те, что справа) бита, все остальные — потеряются.

Например, если мы попытаемся поместить число 21 в нашу 4-битную переменную:

Десятичная система Двоичная система
21 10101

Число 21 занимает 5 бит (10101). 4 бита справа (0101) поместятся в переменную, а крайний левый бит (1) просто потеряется. Т.е. наша переменная будет содержать 0101, что равно 101 (нуль спереди не считается), а это уже число 5, а не 21.

Примечание: О конвертации чисел из двоичной системы в десятичную и наоборот будет отдельный урок, где мы всё детально рассмотрим и обсудим.

Теперь рассмотрим пример в коде (тип short занимает 16 бит):

#include <iostream> int main() { unsigned short x = 65535; // наибольшее значение, которое может хранить 16-битная unsigned переменная std::cout << «x was: » << x << std::endl; x = x + 1; // 65536 — это число больше максимально допустимого числа из диапазона допустимых значений. Следовательно, произойдёт переполнение, так как переменнная x не может хранить 17 бит std::cout << «x is now: » << x << std::endl; return 0; }

#include <iostream>

int main()

{

    unsigned short x = 65535; // наибольшее значение, которое может хранить 16-битная unsigned переменная

    std::cout << «x was: » << x << std::endl;

    x = x + 1; // 65536 — это число больше максимально допустимого числа из диапазона допустимых значений. Следовательно, произойдёт переполнение, так как переменнная x не может хранить 17 бит

    std::cout << «x is now: » << x << std::endl;

    return 0;

}

Результат выполнения программы:

x was: 65535
x is now: 0

Что случилось? Произошло переполнение, так как мы попытались присвоить переменной x значение больше, чем она способна в себе хранить.

Для тех, кто хочет знать больше: Число 65 535 в двоичной системе счисления представлено как 1111 1111 1111 1111. 65 535 — это наибольшее число, которое может хранить 2-байтовая (16 бит) целочисленная переменная без знака, так как это число использует все 16 бит. Когда мы добавляем 1, то получаем число 65 536. Число 65 536 представлено в двоичной системе как 1 0000 0000 0000 0000, и занимает 17 бит! Следовательно, самый главный бит (которым является 1) теряется, а все 16 бит справа — остаются. Комбинация 0000 0000 0000 0000 соответствует десятичному 0, что и является нашим результатом.

Аналогичным образом, мы получим переполнение, использовав число меньше минимального из диапазона допустимых значений:

#include <iostream> int main() { unsigned short x = 0; // наименьшее значение, которое 2-байтовая unsigned переменная может хранить std::cout << «x was: » << x << std::endl; x = x — 1; // переполнение! std::cout << «x is now: » << x << std::endl; return 0; }

#include <iostream>

int main()

{

    unsigned short x = 0; // наименьшее значение, которое 2-байтовая unsigned переменная может хранить

    std::cout << «x was: » << x << std::endl;

    x = x — 1; // переполнение!

    std::cout << «x is now: » << x << std::endl;

    return 0;

}

Результат выполнения программы:

x was: 0
x is now: 65535

Переполнение приводит к потере информации, а это никогда не приветствуется. Если есть хоть малейшее подозрение или предположение, что значением переменной может быть число, которое находится вне диапазона допустимых значений используемого типа данных — используйте тип данных побольше!

Правило: Никогда не допускайте возникновения переполнения в ваших программах!

Деление целочисленных переменных

В языке C++ при делении двух целых чисел, где результатом является другое целое число, всё довольно предсказуемо:

#include <iostream> int main() { std::cout << 20 / 4 << std::endl; return 0; }

#include <iostream>

int main()

{

    std::cout << 20 / 4 << std::endl;

    return 0;

}

Результат:

5

Но что произойдет, если в результате деления двух целых чисел мы получим дробное число? Например:

#include <iostream> int main() { std::cout << 8 / 5 << std::endl; return 0; }

#include <iostream>

int main()

{

    std::cout << 8 / 5 << std::endl;

    return 0;

}

Результат:

1

В языке C++ при делении целых чисел результатом всегда будет другое целое число. А такие числа не могут иметь дробь (она просто отбрасывается, не округляется!).

Рассмотрим детально пример выше: 8 / 5 = 1.6. Но, как мы уже знаем, при делении целых чисел, результатом является другое целое число. Таким образом, дробная часть (0.6) значения отбрасывается и остается 1.

Правило: Будьте осторожны при делении целых чисел, так как любая дробная часть всегда отбрасывается.


Оценить статью:

Загрузка…

Поделиться в социальных сетях:

Тип данных Integer.

Тип INTEGER (целый). Этот тип представляет множество целых чисел диапазона от -32768 до 32767. В памяти ЭВМ  под целое число отводится два байта (16 бит).

Наибольшему значению целого числа 32767 соответствует стандартный идентификатор MAXINT, а наименьшему – выpaжeниe NOT(MAXINT)=-(MAXINT+1), или число -32768. Операции, проводимые над целыми числами: «+» сложение, «-» вычитание, «*» умножение, DIV — целочисленное деление, MOD — остаток от целочисленного деления, AND — арифметическое ‘И’, OR — арифметическое ‘ИЛИ’, NOT – арифметическое отрицание, XOR — исключающая дизъюнкция. Примеры использования этих операций приведены в таблице1.

Любая из этих операций выполнима над двумя целыми числами, если абсолютная величина результата не превышает MAXINT (для умножения). В противном случае возникает прерывание программы, связанное с переполнением.
Например: требуется вычислить выражение 1000 * 4000 div 2000. Поскольку операции умножения и деления имеют один приоритет и выполняются слева направо в порядке записи арифметического выражения, то при умножении произойдет прерывание, связанное с переполнением. Выход из этой ситуации возможен при изменении порядка выполнения операций умножения и деления, для чего используются круглые скобки ==> 1000 * (4000 div 2000).
Предусмотрено представление целых чисел в шестнадцатеричной системе счисления. Форма записи таких чисел $Х, где X — целая константа, а символ $ — признак. Примеры: $57, $1FF. Напомним, что в шестнадцатеричной системе счисления цифры 10, 11, 12, 13, 14 и 15 заменяются латинскими буквами А, В, С, D, Е и F соответственно.
Кроме типа INTEGER в языке Pascal предусмотрены и другие целые типы данных BYTE, SHORTINT, WORD и LONGINT (таблица 2). Все эти типы определены на множестве целых чисел, характеризуются одним набором арифметических операций и отличаются диапазоном значений и объемом занимаемой памяти.


Предыдущая статья: Алфавит языка Pascal.
Оглавление: Лекции по Pascal.
Следующая статья: Тип данных Real.


Типы данных в информатике. Тип Integer

К концу 2018 года в мире насчитывается несколько сот языков программирования, меньшая часть из них представлена узкоспециализированными языками, такими как, например, Ada (язык, изобретенный ВВС США для управления баллистическими ракетами) или Fortran, в основном применяемый в научной разработке программного обеспечения. Но большинство из них общедоступно для понимания и изучения и находят широкое применение.

Типы данных в информатике — это структурная и размерная характеристика выделенной ячейки памяти, в которую можно поместить некоторое значение для дальнейших операций. Одним из таких типов является тип integer (int). Это целочисленный тип данных. То есть поместить в зарезервированную ячейку типа integer можно только целое число (0, 1, 2, 256, 10000 и так далее).

Диапазон значений, которые можно положить в ячейку типа integer, отличается в других языках программирования и на разных процессорах, например в языке программирования Pascal составляет от -32768 до 32768. Попытка «положить» данные больше или меньше данного диапазона вызовет «ошибку переполнения данных».

Характеристики типа данных integer

В 32-разрядных архитектурах занимают от −2 147 483 648 (-231) до 2 147 483 647 (231−1)

Существуют типы integer, без знаков. Например, unsigned int в C#. Неправильное использование таких типов данных может приводить к ошибкам.

Также существуют различные вариации типа integer, такие как:

  • short int — предусматривается с целью сократить количество памяти, выделяемой под нужды программиста.
  • long int — напротив, создан для тех, кто боится, что в ходе работы программы есть риск «вылететь» за пределы обычного int и получить «ошибку переполнения данных».

Типы integer, real, dint (в языке Pascal) относятся к математическим типам данных. Это значит, что возможно производить математические действия — сложение, умножение, вычитание, деление.

Характеристики типа integer real

Для запоминания вещественного числа в ОЗУ отводится шесть байтов памяти, поэтому расчеты всегда выполняются с конечной точностью, зависящей от формата числа. Вещественные данные хранятся как целое число с плавающей десятичной точкой.

Другие типы данных в популярных языках программирования

Char — символьный тип данных, может хранить в себе 1 символ из таблицы символов ASCII. Занимает 1 байт и интерпретируется как символ ASCII.

String — строковый тип данных, обычно представлен массивом объектов типа char. Обычно возможности современных языков позволяют совершать самые разнообразные действия над объектами типа string, например конкатенацию (склеивание), удаление строк, замену символов в строке.

Boolean — логический тип данных. Примитивный тип данных в информатике, выражающий 2 состояния. Очень полезен, когда в программе необходимо выразить только 2 состояния (например, написать функцию, которая бы возвращала только правду или ложь).

Приведение типов

Языки программирования позволяют «приводить» типы друг к другу. Например, инициализировав переменную типа integer, мы можем в дальнейшем привести ее к типу double, то есть разрешить компилятору перезаписать ее и обращаться с ней в дальнейшем как с числом с плавающей точкой.

Но не все типы данных возможно так просто преобразовывать. Например, мы никак не приведем string к integer, компилятор просто не поймет наших действий. Также есть частные случаи компиляторов и языков программирования. Например, в языке Pascal нельзя преобразовать тип integer к integer real, потому что только тип real поддерживает операцию деления.

В современных языках, таких как C#, нет таких проблем, чаще всего программист может безболезненно преобразовывать интуитивно похожие типы данных, такие как int. double, long int и так далее. Более того, в динамически типизируемых языках даже возможна ситуация, когда тип данных char приводится к int!

Это дозволено потому, что компилятор, вместо того, чтобы работать с символом, берет его порядковый номер из таблицы ASCII и уже его использует для взаимодействия с int. В языках со строгой типизацией, таких как C++ или C#, это, конечно же, невозможно.

Это основные типы данных в информатике. В современных языках программирования переменные часто представляют собой уже не просто выделенное место в оперативной памяти, а целые «объекты» или «классы», что сильно расширяет возможности операций с ними.

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

Целые типы

В языке Паскаль определено пять целых типов.

Таблица. Целые типы Pascal

Тип Диапазон допустимых значений Отводимая память, в байтах
shortint -128…127 1
integer -32 768…32 767 2
longint -2 147 483 648…2 147 483 647 4
byte 0…255 1
word 0…65 535 2

Переменные целого типа могут принимать только целые значения. Такие переменные в программе описываются следующим образом:

Здесь a, b, c… — имена переменных, integer – тип переменных. Транслятор, встретив такое описание переменных a, b, c, запоминает, что эти переменные могут принимать только целые значения и формирует соответственно этому команды программы.

Таблица. Операции над целыми типами, дающие в результате значение целого типа

Знак операции Операция
+ Сложение
Вычитание
* Умножение
div Целочисленное деление (остаток отбрасывается). Деление без округления (целая часть частного).
mod Деление по модулю (выделение остатка от деления). Остаток от деления: a mod b = a – ((a div b) * b).

Операции над операндами целого типа выполняются правильно только при условии, что результат и каждый операнд не меньше минимального (крайнего левого) и не больше максимального (крайнего правого) значений диапазона. Например, в Паскале существует константа maxint, в которой содержится максимально допустимое значение для типа integer. Тогда при выполнении операций в программе должны соблюдаться следующие условия:
(a операция b) <= maxint,
a <= maxint, b <= maxint.

Над целыми типами, как и многими другими, допустимы операции отношения (сравнения). Результат таких операций относится к типу boolean и может принимать одно из двух значений – либо true (истина), либо false (ложь).

Таблица. Операции отношения

Знак операции Операция
= Равно
<> Не равно
>= Больше или равно
> Больше
<= Меньше или равно
< Меньше

Целые типы могут приниматься в качестве фактических параметров рядом стандартных функций языка программирования Pascal.

Таблица. Стандартные функции Pascal, применимые к аргументам целых типов

Функция Тип результата Результат выполнения
abs(x) Целый Модуль x (абсолютная величина x)
sqr(x) Целый Квадрат x
succ(x) Целый Следующее значение x (x+1)
pred(x) Целый Предыдущее значение x (x-1)
random(x) Целый Случайное целое число из интервала 0..x-1.
sin(x) Действительный Синус x (угол в радианах)
cos(x) Действительный Косинус x (угол в радианах)
arctan(x) Действительный Арктангенс x (угол в радианах)
ln(x) Действительный Натуральный логарифм x
exp(x) Действительный Экспонента x
sqrt(x) Действительный Квадратный корень из x
odd(x) Логический Значение true, если x – нечетное число; false – если четное.

Функция random возвращает равномерно распределенное случайное целое число, если ей передан целый аргумент. При повторном запуске программы она возвращает те же значения. Во избежание этого следует в начале программы вызвать процедуру без параметров randomize.

Процедуры inc и dec могут иметь по одному или по два параметра целого типа. Если параметров два, то значение первого увеличивается (для inc) или уменьшается (для dec) на величину, равную значению второго параметра. Например, inc(x,2) равнозначно x+2. Если параметр один, то его значение увеличивается (для inc) или уменьшается (для dec) на единицу. Например, dec(x) равнозначно x-1. (ТАКИХ ПРОЦЕДУР ВО FREEPASCAL СКОРЕЕ ВСЕГО НЕТ.)

Следующие функции принимают в качестве аргументов значения вещественного типа, а возвращают значения целого типа:
trunc(x) – отбрасывание десятичных знаков после точки;
round(x) – округление до целого.

Примеры работы некоторых приведенных выше операций и функций:
Пример 1. Пусть a = 17, b = 5. Тогда a div b дает 3, a mod b дает 2 (остаток от деления), sqr(b) дает 25.
Пример 2. Пусть x = 4.7389. Тогда trunc(x) дает 4, round(x) дает 5.
Пример 3. Выражение 4 * 21 дает результат целого типа, а 4 * 21.0 – вещественного, т.к. один из сомножителей вещественный.

Справочник по C#. Целочисленные типы

  • Чтение занимает 2 мин

В этой статье

Целочисленные типы представляют целые числа.The integral numeric types represent integer numbers. Все целочисленные типы являются типами значений.All integral numeric types are value types. Они также представляют собой простые типы и могут быть инициализированы литералами.They are also simple types and can be initialized with literals. Все целочисленные типы поддерживают арифметические операторы, побитовые логические операторы, операторы сравнения и равенства.All integral numeric types support arithmetic, bitwise logical, comparison, and equality operators.

Характеристики целочисленных типовCharacteristics of the integral types

C# поддерживает следующие предварительно определенные целочисленные типы:C# supports the following predefined integral types:

Ключевое слово или тип C#C# type/keyword ДиапазонRange РазмерSize Тип .NET.NET type
sbyte От -128 до 127-128 to 127 8-разрядное целое число со знакомSigned 8-bit integer System.SByte
byte От 0 до 2550 to 255 8-разрядное целое число без знакаUnsigned 8-bit integer System.Byte
short От -32 768 до 32 767-32,768 to 32,767 16-разрядное целое число со знакомSigned 16-bit integer System.Int16
ushort От 0 до 65 5350 to 65,535 16-разрядное целое число без знакаUnsigned 16-bit integer System.UInt16
int От -2 147 483 648 до 2 147 483 647-2,147,483,648 to 2,147,483,647 32-разрядное целое число со знакомSigned 32-bit integer System.Int32
uint От 0 до 4 294 967 2950 to 4,294,967,295 32-разрядное целое число без знакаUnsigned 32-bit integer System.UInt32
long От -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 64-разрядное целое число со знакомSigned 64-bit integer System.Int64
ulong От 0 до 18 446 744 073 709 551 6150 to 18,446,744,073,709,551,615 64-разрядное целое число без знакаUnsigned 64-bit integer System.UInt64

В приведенной выше таблице каждый тип ключевого слова C# из крайнего левого столбца является псевдонимом для соответствующего типа .NET.In the preceding table, each C# type keyword from the leftmost column is an alias for the corresponding .NET type. Они взаимозаменяемые.They are interchangeable. Например, следующие объявления объявляют переменные одного типа:For example, the following declarations declare variables of the same type:

int a = 123;
System.Int32 b = 123;

По умолчанию все целочисленные типы имеют значение 0.The default value of each integral type is zero, 0. Все целочисленные типы имеют константы MinValue и MaxValue с минимальным и максимальными итоговыми значениями этого типа.Each of the integral types has the MinValue and MaxValue constants that provide the minimum and maximum value of that type.

Используйте структуру System.Numerics.BigInteger, чтобы представить целое число со знаком без верхней и нижней границ.Use the System.Numerics.BigInteger structure to represent a signed integer with no upper or lower bounds.

Целочисленные литералыInteger literals

Целочисленные литералы могут быть:Integer literals can be

  • десятичным числом: без префикса;decimal: without any prefix
  • шестнадцатеричным числом: с префиксом 0x или 0X;hexadecimal: with the 0x or 0X prefix
  • двоичными: с префиксом 0b или 0B (доступно в C# 7.0 и более поздних версиях).binary: with the 0b or 0B prefix (available in C# 7.0 and later)

В приведенном ниже коде показан пример каждого из них.The following code demonstrates an example of each:

var decimalLiteral = 42;
var hexLiteral = 0x2A;
var binaryLiteral = 0b_0010_1010;

В предыдущем примере также показано использование _ в качестве цифрового разделителя, который поддерживается, начиная с версии C# 7.0.The preceding example also shows the use of _ as a digit separator, which is supported starting with C# 7.0. Цифровой разделитель можно использовать со всеми видами числовых литералов.You can use the digit separator with all kinds of numeric literals.

Тип целочисленного литерала определяется его суффиксом следующим образом:The type of an integer literal is determined by its suffix as follows:

  • Если литерал не имеет суффикса, его типом будет первый из следующих типов, в котором может быть представлено его значение: int, uint, long, ulong.If the literal has no suffix, its type is the first of the following types in which its value can be represented: int, uint, long, ulong.

  • Если у литерала есть суффикс U или u, его типом будет первый из следующих типов, в котором может быть представлено его значение: uint, ulong.If the literal is suffixed by U or u, its type is the first of the following types in which its value can be represented: uint, ulong.

  • Если у литерала есть суффикс L или l, его типом будет первый из следующих типов, в котором может быть представлено его значение: long, ulong.If the literal is suffixed by L or l, its type is the first of the following types in which its value can be represented: long, ulong.

    Примечание

    Строчную букву l можно использовать в качестве суффикса.You can use the lowercase letter l as a suffix. Однако при этом выдается предупреждение компилятора, так как букву l можно перепутать с цифрой 1.However, this generates a compiler warning because the letter l can be confused with the digit 1. Для ясности используйте L.Use L for clarity.

  • Если у литерала есть суффикс UL, Ul, uL, ul, LU, Lu, lU или lu, его тип — ulong.If the literal is suffixed by UL, Ul, uL, ul, LU, Lu, lU, or lu, its type is ulong.

Если значение, представленное целочисленным литералом, превышает UInt64.MaxValue, происходит ошибка компиляции CS1021.If the value represented by an integer literal exceeds UInt64.MaxValue, a compiler error CS1021 occurs.

Если определенный тип целочисленного литерала — int, а значение, представленное литералом, находится в диапазоне целевого типа, значение можно неявно преобразовать в sbyte, byte, short, ushort, uint или ulong:If the determined type of an integer literal is int and the value represented by the literal is within the range of the destination type, the value can be implicitly converted to sbyte, byte, short, ushort, uint, or ulong:

byte a = 17;
byte b = 300;   // CS0031: Constant value '300' cannot be converted to a 'byte'

Как показано в предыдущем примере, если значение литерала выходит за пределы диапазона целевого типа, возникает ошибка компилятора CS0031.As the preceding example shows, if the literal’s value is not within the range of the destination type, a compiler error CS0031 occurs.

Можно также использовать приведение для преобразования значения, представленного целочисленным литералом, в тип, отличный от определенного типа литерала:You can also use a cast to convert the value represented by an integer literal to the type other than the determined type of the literal:

var signedByte = (sbyte)42;
var longVariable = (long)42;

ПреобразованияConversions

Любой целочисленный тип можно преобразовать в любой другой целочисленный тип.You can convert any integral numeric type to any other integral numeric type. Если целевой тип может хранить все значения исходного типа, преобразование является неявным.If the destination type can store all values of the source type, the conversion is implicit. В противном случае необходимо использовать выражение приведения для выполнения явного преобразования.Otherwise, you need to use a cast expression to perform an explicit conversion. Для получения дополнительной информации см. статью Встроенные числовые преобразования.For more information, see Built-in numeric conversions.

Спецификация языка C#C# language specification

Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:For more information, see the following sections of the C# language specification:

См. такжеSee also

Pascal. Простые типы данных — Pascal

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

Простые типы делятся на стандартные (порядковые) и перечисляемые (ограниченные).

Стандартные типы

Турбо-Паскаль имеет четыре встроенных стандартных типа: integer (целое), real (вещественное), boolean (логический) и char (символьный).

Целочисленный тип (integer)

В Турбо-Паскале имеется пять встроенных целочисленных типов: shortint (короткое целое), integer (целое), longint (длинное целое), byte (длиной в байт) и word (длиной в слово). Каждый тип обозначает определенное подмножество целых чисел, как это показано в следующей Таблице.

Встроенные целочисленные типы.

Тип

Диапазон

Формат

shortint

-128 ..+127

8 битов со знаком

integer

-32768 .. 32767

16 битов со знаком

longint

-2147483648 +2147483647

32 бита со знаком

byte

0 .. 255

8 битов без знака

word

0 .. 65535

16 битов без знака

Арифметические действия над операндами целочисленного типа осуществляются в соответствии со следующими правилами:

  1. Тип целой константы представляет собой встроенный целочисленный тип с наименьшим диапазоном, включающим значение этой целой константы.
  2. В случае бинарной операции (операции, использующей два операнда), оба операнда преобразуются к их общему типу перед тем, как над ними совершается действие. Общим типом является встроенный целочисленный тип с наименьшим диапазоном, включающим все возможные значения обоих типов. Например, общим типом для целого и целого длиной в байт является целое, а общим типом для целого и целого длиной в слово является длинное целое. Действие выполняется в соответствии с точностью общего типа и типом результата является общий тип.
  3. Выражение справа в операторе присваивания вычисляется независимо от размера переменной слева.

Операции совершаемые над целыми числами:

“+” — сложение

“-“ — вычитание

“*” — умножение

SQR — возведение в квадрат

DIV — после деления отбрасывает дробную часть

MOD — получение целого остатка после деления

ABS — модуль числа

RANDOM(X)-получение случайного числа от 0 до Х

Пример:

а:=100; 
b:=60;
a DIV b результат - 1
а MOD b результат - 40

Описываются переменные целого типа следующим образом:

var список переменных: тип;

Например: var а,р,n:integer;

Вещественный тип(real)

К вещественному типу относится подмножество вещественных чисел, которые могут быть представлены в формате с плавающей запятой с фиксированным числом цифр. Запись значения в формате с плавающей запятой обычно включает три значения — m, b и e — таким образом, что m*bе, где b всегда равен 10, а m и e являются целочисленными значениями в диапазоне вещественного типа. Эти значения m и e далее определяют диапазон и точность вещественного типа.

Имеется пять видов вещественных типов: real, singlе, duble, exnende, comp. Вещественные типы различаются диапазоном и точностью связанных с ними значений

Диапазон и десятичные цифры для вещественных типов

Тип

Диапазон

Цифры

Real

Single

Duble

Extende

comp

2.9×10Е-39 до 1.7×10Е 38

1.5×10Е-45 до 3.4×10Е 38

5.0×10Е-324 до 1.7×10Е 308

3.4×10Е-493 до 1.1×10Е 403

-2Е 63 до 2Е 63

от 11 до 12

от 7 до 8

от 15 до 16

от 19 до 20

от 19 до 20

Операции совершаемые над вещественными числами:

  • Все операции допустимые для целых чисел.
  • SQRT(x)-корень квадратный из числа х.
  • SIN(X), COS(X), ARCTAN(X).
  • LN(X)-натуральный логарифм.
  • EXP(X)-экспонента Х (ех).
  • EXP(X*LN(A))-возведение в степень (Ах).
  • Функции преобразования типов:
    • TRUNC(X)-отбрасывает дробную часть;
    • ROUND(X)-округление.
  • Некоторые правила арифметических операций:
    • Если в арифметическом действии встречаются числа типа real и integer, то результат будет иметь тип real.
    • Все составные части выражения записываются в одну строку.
    • Используются только круглые скобки.
    • Нельзя подряд ставить два арифметических знака.

Описываются переменные вещественного типа следующим образом:

var список переменных: тип;

Например:

var d,g,k:real;

Символьный тип(char)

K типу char относится любой символ заключенный в апострофы. Для представления апострофа как символьную переменную, надо заключить его в апостроф:’’’’.

Каждый символ имеет свой код и номер. Порядковые номера цифр 0,1..9 упорядочены по возрастанию. Порядковые номера букв также упорядочены по возрастанию, но не обязательно следуют друг за другом.

К символьным данным применимы знаки сравнения:

> , < , >=, <=, <> .

Например: ‘A’ < ‘W’

Функции, которые применимы к символьным переменным:

  1. ORD(X) — определяет порядковый номер символа Х.

    Пример:

    ord(‘a’)=97;
  2. CHR(X) — определяет символ по номеру.

    Пример:

    chr(97)=’a’;
  3. PRED(X) — выдает символ, стоящий перед символом Х.

    Пример:

    pred(‘B’)=’A’;
  4. SUCC(X) — выдает символ, следующий после символа Х.

    Пример:

    succ(‘A’)=’B’;

Перечислимый тип

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

Type <имя типа>=(список констант);
Var <имя переменной>:<имя типа>;
 

где <список констант> — это особый вид констант, задаваемых через запятую и имеющих свой порядковый номер, начиная с 0.

Например:

type
направление=(север, юг, запад, восток);
месяц=(июнь,июль,август,январь);
емкость=(ведро,бочка,канистра,бак);
var
поворот:направление;
отъезд:месяц;
объем:емкость;
 

или так:

var
поворот:(свер, юг, запад, восток);
отъезд:(июнь, июль, август, январь);
объем:(ведро, бочка, канистра, бак);
 

Можно выполнить такие операторы присваивания:

поворот:=юг;
отъезд:=август;
объем:=бак;

но нельзя выполнять смешанные присваивания:

отъезд:=юг;
объем:=август;
 

К переменным перечислимого типа применимы следующие функции:

1. ORD — порядковый номер

2. PRED — предшествующий элемент

3. SUCC — последующий элемент.

Пример:

PRED(бочка)=ведро; 
SUCC(юг)=запад; 
ORD(июль)=1;
 

Переменные перечислимого типа можно сравнить, так как они упорядочены и пронумерованы. Так выражения: север < юг, июнь < январь имеют значения TRUE, а юг>запад и бак<бочка значение FАLSE.

Ограниченный тип

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

Описывается так:

TYPE <имя типа>=константа1..константа2

При этом должны выполняться следующие правила:

  1. Обе ограниченные константы должны быть одного типа.
  2. В качестве базового типа можно использовать любой простой тип, кроме действительного(real).
  3. Начальные значение при определении ограниченного типа не должно быть больше конечного значения.

Пример:

type index=0..63;
letter=’a’..’z’; var char1,char2:letter;
a,g:index;

Можно описывать сразу в разделе описания переменных:

var a,g:0..63;
char1,char2:’a’..’z’.
Целочисленный тип данных

— Visual Basic

  • 3 минуты, чтобы прочитать

В этой статье

Содержит 32-разрядные (4-байтовые) целые числа со знаком, значения которых варьируются от -2 147 483 648 до 2 147 483 647.

Замечания

Тип данных Integer обеспечивает оптимальную производительность на 32-разрядном процессоре. Другие интегральные типы медленнее загружать и хранить из памяти и в память.

Значение по умолчанию Integer равно 0.

Буквальные задания

Вы можете объявить и инициализировать переменную Integer , присвоив ей десятичный литерал, шестнадцатеричный литерал, восьмеричный литерал или (начиная с Visual Basic 2017) двоичный литерал.Если целочисленный литерал находится вне диапазона Integer (то есть, если он меньше Int32.MinValue или больше Int32.MaxValue, возникает ошибка компиляции.

В следующем примере целым числам присваиваются целые числа, равные 90 946, которые представлены в виде десятичных, шестнадцатеричных и двоичных литералов.

  Dim intValue1 As Integer = 90946
ЕЫпе (intValue1)
Dim intValue2 As Integer = & h26342
ЕЫпе (intValue2)

Dim intValue3 As Integer = & B0001_0110_0011_0100_0010
Приставка.ЕЫпе (intValue3)
'В примере показан следующий вывод:
90946
90946
90946
  

Примечание

Вы используете префикс & h или & H для обозначения шестнадцатеричного литерала, префикс & b или & B для обозначения двоичного литерала и префикс и o или & O для обозначения восьмеричного литерала. Десятичные литералы не имеют префикса.

Начиная с Visual Basic 2017, вы также можете использовать символ подчеркивания _ в качестве разделителя цифр для улучшения читабельности, как показано в следующем примере.

  Dim intValue1 As Integer = 90_946
ЕЫпе (intValue1)

Dim intValue2 As Integer = & H0001_6342
ЕЫпе (intValue2)

Dim intValue3 As Integer = & B0001_0110_0011_0100_0010
ЕЫпе (intValue3)
'В примере показан следующий вывод:
90946
90946
90946
  

Начиная с Visual Basic 15.5, вы также можете использовать символ подчеркивания ( _ ) в качестве ведущего разделителя между префиксом и шестнадцатеричной, двоичной или восьмеричной цифрами.Например:

  Тусклое число как целое число = & H_C305_F860
  

Чтобы использовать символ подчеркивания в качестве начального разделителя, необходимо добавить следующий элемент в файл проекта Visual Basic (* .vbproj):

  
   15.5 

  

Для получения дополнительной информации см. Настройку языковой версии Visual Basic.

Числовые литералы

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

  Тусклый номер = & H_035826I
  

Советы по программированию

  • Соображения о взаимодействии. Если вы взаимодействуете с компонентами, не написанными для .NET Framework, такими как объекты автоматизации или COM, помните, что Integer имеет другую ширину данных (16 бит) в других средах. Если вы передаете 16-битный аргумент такому компоненту, объявите его как Short вместо Integer в вашем новом коде Visual Basic.

  • Расширение. Тип данных Integer расширяется до Long , Decimal , Single или Double . Это означает, что вы можете конвертировать Integer в любой из этих типов без возникновения ошибки System.OverflowException.

  • Тип Персонажи. При добавлении буквального типа 9009 I к литералу его переводят в тип данных Integer . При добавлении идентификатора типа символа % к любому идентификатору устанавливается значение Integer .

  • Тип рамы. Соответствующим типом в .NET Framework является структура System.Int32.

Диапазон

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

  'Допустимый диапазон целочисленной переменной: от -2147483648 до +2147483647.
Dim K As Integer
«Следующее утверждение вызывает ошибку, поскольку значение слишком велико.
k = 2147483648
«Следующее утверждение устанавливает k в 6.
к = 5,9
«Следующее утверждение устанавливает к 4
к = 4,5
«Следующее утверждение устанавливает к 6
'Примечание: Visual Basic использует округление банкира (до ближайшего четного числа)
к = 5,5
  

См. Также

,

Тип данных резюме | Microsoft Docs

  • 3 минуты, чтобы прочитать

В этой статье

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

Набор внутренних типов данных

В следующей таблице приведены поддерживаемые типы данных, включая размеры и диапазоны хранения.

От От
Тип данных Объем хранения Диапазон
Boolean 2 байта True или False
Байт 1 байт от 0 до 255
Коллекция Неизвестно Неизвестно
Валюта (масштабированное целое число) 8 байтов -922,337,203,685,477.С 5808 до 922 337 203 685 477,5807
Дата 8 байтов от 1 января 100 до 31 декабря 9999
Десятичное число 14 байтов +/- 79,228,162,514,264,337,593,543,950,335 без десятичной точки

+/- 7.9228162514264337593543950335 с 28 знаками справа от десятичной дроби

Наименьшее ненулевое число равно +/- 0,0000000000000000000000000001

Словарь Неизвестно Неизвестно
Двойной (двойная точность с плавающей точкой) 8 байтов -1.От 79769313486231E308 до -4.94065645841247E-324 для отрицательных значений

4.94065645841247E-324 до 1.79769313486232E308 для положительных значений

Целое число 2 байта — от 32 768 до 32 767
Long (Long integer) 4 байта -2 147 483 648 до 2 147 483 647
LongLong (LongLong integer) 8 байтов -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807

Действительно только на 64-битных платформах.

LongPtr (длинное целое в 32-битных системах, длинное целое в 64-битных системах) 4 байта в 32-битных системах

8 байтов в 64-битных системах

-2 147 483 648 до 2 147 483 647 в 32-разрядных системах

-9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 в 64-разрядных системах

Объект 4 байта Любой Объект Ссылка
Одиночный (с плавающей точкой одинарной точности) 4 байта -3.От 402823E38 до -1.401298E-45 для отрицательных значений

1.401298E-45 до 3.402823E38 для положительных значений

Строка (переменной длины) 10 байтов + длина строки до 2 миллиардов
Строка (фиксированная длина) Длина нити 1 до примерно 65 400
Вариант (с номерами) 16 байтов Любое числовое значение до диапазона Двойной
Вариант (с символами) 22 байта + длина строки (24 байта в 64-битных системах) Тот же диапазон, что и для переменной длины Строка
Определяемый пользователем (с использованием Тип ) Номер, необходимый для элементов Диапазон каждого элемента совпадает с диапазоном его типа данных.

Вариант , содержащий массив, требует на 12 байтов больше, чем один массив.

Примечание

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

Например, данные в одномерном массиве, состоящем из 4 целых элементов данных по 2 байта каждый, занимают 8 байтов.8 байтов, требуемых для данных, плюс 24 байта служебных данных, увеличивают общую потребность в памяти для массива до 32 байтов. На 64-битных платформах SAFEARRAY занимают 24 бита (плюс 4 байта на оператор Dim). Член pvData является 8-байтовым указателем и должен быть выровнен по 8-байтовым границам.

Примечание

LongPtr не является истинным типом данных, поскольку он преобразуется в Long в 32-разрядных средах или LongLong в 64-разрядных средах. LongPtr должен использоваться для представления указателя и обработки значений в операторах Declare и позволяет писать переносимый код, который может работать как в 32-разрядных, так и в 64-разрядных средах.

Примечание

Используйте функцию StrConv для преобразования одного типа строковых данных в другой.

Преобразование между типами данных

См. Функции преобразования типов для примеров использования следующих функций для приведения выражения к определенному типу данных: CBool ​​, CByte , CCur , CDate , CDbl , CDec , CInt , CLng , CLngLng , CLngPtr , CSng , CStr и CVar .

Для получения дополнительной информации см. Соответствующие страницы функций: CVErr , Fix и Int .

Примечание

CLngLng действует только на 64-битных платформах.

Проверка типов данных

Для проверки типов данных см. Следующие функции:

Возвращаемые значения для CStr

Если , выражение равно CStr возвращает
Boolean Строка, содержащая True или False .
Дата Строка, содержащая дату в формате короткой даты вашей системы.
Пусто Строка нулевой длины («»).
Ошибка Строка, содержащая слово Ошибка , за которым следует номер ошибки.
Нуль Ошибка во время выполнения.
Другие числовые Строка, содержащая число.

См. Также

Поддержка и обратная связь

Есть вопросы или отзывы о Office VBA или этой документации? Пожалуйста, ознакомьтесь с поддержкой и отзывами Office VBA, чтобы узнать, как можно получить поддержку, и оставить отзыв.

,

Интегральные числовые типы — C # ссылка

  • 3 минуты, чтобы прочитать

В этой статье

Целочисленные числовые типы представляют собой целые числа.Все целочисленные числовые типы являются типами значений. Они также являются простыми типами и могут быть инициализированы литералами. Все целочисленные числовые типы поддерживают арифметические, побитовые логические операторы, операторы сравнения и равенства.

Характеристики целочисленных типов

C # поддерживает следующие предопределенные целочисленные типы:

Система От Система
C # тип / ключевое слово Диапазон Размер . NET тип
сбайт -128 до 127 8-разрядное целое число со знаком .SByte
байт от 0 до 255 8-разрядное целое число без знака System.Byte
короткие до 32 768 до 32 767 16-разрядное целое число со знаком System.Int16
ushort от 0 до 65 535 16-разрядное целое число без знака System.UInt16
и -2 147 483 648 до 2 147 483 647 32-разрядное целое число со знаком .Int32
уинт от 0 до 4 294 967 295 32-разрядное целое число без знака System.UInt32
длиной -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807 64-разрядное целое число со знаком System.Int64
ulong от 0 до 18 446 744 073 709 551 615 64-разрядное целое число без знака System.UInt64

В предыдущей таблице каждое ключевое слово типа C # из крайнего левого столбца является псевдонимом для соответствующего.Чистый тип. Они взаимозаменяемы. Например, следующие объявления объявляют переменные одного типа:

  int a = 123;
System.Int32 b = 123;
  

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

Используйте структуру System.Numerics.BigInteger для представления целого числа со знаком без верхних или нижних границ.

целочисленных литералов

Целочисленные литералы могут быть

  • десятичный : без префикса
  • шестнадцатеричный : с префиксом 0x или 0X
  • двоичный : с префиксом 0b или 0B (доступно в C # 7.0 и более поздних версиях)

Следующий код демонстрирует пример каждого:

  var decimalLiteral = 42;
var hexLiteral = 0x2A;
var binaryLiteral = 0b_0010_1010;
  

В предыдущем примере также показано использование _ в качестве -разрядного разделителя , который поддерживается начиная с C # 7.0. Вы можете использовать разделитель цифр со всеми видами числовых литералов.

Тип целочисленного литерала определяется его суффиксом следующим образом:

  • Если у литерала нет суффикса, его тип является первым из следующих типов, в которых может быть представлено его значение: , , , , , , и .

  • Если к литералу добавляется U или u , его тип является первым из следующих типов, в которых может быть представлено его значение: uint , ulong .

  • Если к литералу добавляется L или l , его тип является первым из следующих типов, в которых его значение может быть представлено: длиной , ulong .

    Примечание

    В качестве суффикса можно использовать строчную букву l . Однако при этом генерируется предупреждение компилятора, поскольку букву l можно спутать с цифрой 1 . Используйте L для ясности.

  • Если к литералу добавляется UL , UL , UL , ul , LU , Lu , lU или lu , его тип равен ulong .

Если значение, представленное целочисленным литералом, превышает UInt64.MaxValue, возникает ошибка компилятора CS1021.

Если определенный тип целочисленного литерала равен или , а значение, представленное литералом, находится в диапазоне типа назначения, это значение может быть неявно преобразовано в байта , байта , короткого , ushort , и или и :

  байт а = 17;
байт b = 300; // CS0031: постоянное значение «300» не может быть преобразовано в «байт»
  

Как показывает предыдущий пример, если значение литерала находится за пределами диапазона целевого типа, возникает ошибка компилятора CS0031.

Можно также использовать приведение для преобразования значения, представленного целочисленным литералом, в тип, отличный от определенного типа литерала:

  var signatureByte = (sbyte) 42;
var longVariable = (long) 42;
  

преобразования

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

C # языковая спецификация

Для получения дополнительной информации см. Следующие разделы спецификации языка C #:

См. Также

,Примитивные типы данных
(Учебные руководства Java ™> Изучение языка Java> Основы языка)

Язык программирования Java имеет статическую типизацию, что означает, что все переменные должны быть сначала объявлены, прежде чем их можно будет использовать. Это включает в себя указание типа и имени переменной, как вы уже видели:

Это говорит вашей программе, что поле с именем «gear» существует, содержит числовые данные и имеет начальное значение «1». Тип данных переменной определяет значения, которые она может содержать, плюс операции, которые могут быть выполнены с ней.В дополнение к и язык программирования Java поддерживает семь других примитивных типов данных . Тип примитива предопределен языком и называется зарезервированным ключевым словом. Примитивные значения не разделяют состояние с другими примитивными значениями. Восемь примитивных типов данных, поддерживаемых языком программирования Java:

  • байт : -байтовый тип данных представляет собой 8-разрядное целое число со знаком двоичного числа со знаком. Он имеет минимальное значение -128 и максимальное значение 127 (включительно). байт тип данных может быть полезен для экономии памяти в больших массивы, где экономия памяти действительно имеет значение. Они также могут использоваться вместо и , где их пределы помогают уточнить ваш код; тот факт, что диапазон переменной ограничен, может служить формой документации.

  • short : тип данных short — это 16-разрядное целое число с двоичным знаком со знаком. Он имеет минимальное значение -32 768 и максимальное значение 32 767 (включительно).Как и в случае байт , применяются те же рекомендации: вы можете использовать short для экономии памяти в больших массивах, в ситуациях, когда экономия памяти действительно имеет значение.

  • int : по умолчанию тип данных int представляет собой 32-разрядное целое число со знаком, состоящее из двух чисел со знаком, минимальное значение -2 31 и максимальное значение 2 31 -1. В Java SE 8 и более поздних версиях вы можете использовать тип данных int для представления 32-разрядного целого без знака, которое имеет минимальное значение 0 и максимальное значение 2 32 -1.Используйте класс Integer для использования типа данных int в качестве целого числа без знака. Смотрите раздел Числовые классы для получения дополнительной информации. Статические методы, такие как compareUnsigned , разделяют Unnsigned и т. Д. Были добавлены к Integer Класс для поддержки арифметических операций для целых чисел без знака.

  • длиной : тип данных длиной является 64-разрядным целым числом с дополнением до двух. Подписанный long имеет минимальное значение -2 63 и максимальное значение 2 63 -1.В Java SE 8 и более поздних версиях можно использовать тип данных длиной для представления 64-разрядной длины без знака, которая имеет минимальное значение 0 и максимальное значение 2 64 -1. Используйте этот тип данных, когда вам нужен диапазон значений, более широкий, чем значения, предоставленные и . Класс Long Класс также содержит методы, такие как compareUnsigned , splitUnsigned и т. Д. Для поддержки арифметических операций для длинных без знака.

  • с плавающей запятой : тип данных с плавающей запятой — это 32-битная IEEE 754 с плавающей запятой одинарной точности.Его диапазон значений выходит за рамки этого обсуждения, но указан в Раздел «Типы, форматы и значения с плавающей запятой» в спецификации языка Java. Как и в случае с рекомендациями для байтов, и для коротких , используйте с плавающей запятой (вместо с двойным ), если вам нужно сохранять память в больших массивах чисел с плавающей запятой. Этот тип данных никогда не должен использоваться для точных значений, таких как валюта. Для этого вам нужно будет использовать класс java.math.BigDecimal.Числа и строки охватывают BigDecimal и другие полезные классы, предоставляемые платформой Java.

  • double : тип данных double представляет собой 64-разрядную IEEE 754 с плавающей запятой двойной точности. Его диапазон значений выходит за рамки этого обсуждения, но указан в Раздел «Типы, форматы и значения с плавающей запятой» в спецификации языка Java. Для десятичных значений этот тип данных обычно является выбором по умолчанию. Как упоминалось выше, этот тип данных никогда не должен использоваться для точных значений, таких как валюта.

  • логический : тип данных логический имеет только два возможных значения: истина и ложь . Используйте этот тип данных для простых флагов, которые отслеживают истинные / ложные условия. Этот тип данных представляет один бит информации, но его «размер» не является чем-то точно определенным.

  • char : тип данных char — это один 16-битный символ Unicode. Он имеет минимальное значение '\ u0000' (или 0) и максимальное значение '\ uffff' (или 65 535 включительно).

В дополнение к восьми перечисленным выше примитивным типам данных язык программирования Java также обеспечивает специальную поддержку символьных строк через java.lang.String class. Заключение строки символов в двойные кавычки автоматически создаст новый объект String ; например, String s = "это строка"; Строка объектов являются неизменяемыми , что означает, что после создания их значения не могут быть изменены. Класс String технически не является примитивным типом данных, но, учитывая особую поддержку, предоставляемую ему языком, вы, вероятно, будете думать о нем как таковом.Вы узнаете больше о классе String в Простые объекты данных

Значения по умолчанию

Не всегда необходимо присваивать значение при объявлении поля. Поля, которые объявлены, но не инициализированы, будут установлены разумным значением по умолчанию компилятором. Вообще говоря, это значение по умолчанию будет равно нулю или равно нулю , в зависимости от типа данных. Однако полагаться на такие значения по умолчанию считается плохим стилем программирования.

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

Тип данных Значение по умолчанию (для полей)
байт 0
короткий 0
и 0
длиной 0L
поплавок 0,0f
двойной 0,0d
символов ‘u0000’
Строка (или любой объект) нуль
логическое ложь

Локальные переменные немного отличаются; компилятор никогда не назначает значение по умолчанию для неинициализированной локальной переменной.Если вы не можете инициализировать локальную переменную там, где она объявлена, убедитесь, что вы присвоили ей значение, прежде чем пытаться ее использовать. Доступ к неинициализированной локальной переменной приведет к ошибке во время компиляции.

Литералы

Возможно, вы заметили, что новое ключевое слово не используется при инициализации переменной примитивного типа. Примитивные типы — это специальные типы данных, встроенные в язык; они не являются объектами, созданными из класса. Литерал является представлением исходного кода фиксированного значения; Литералы представлены непосредственно в вашем коде, не требуя вычислений.Как показано ниже, можно присвоить литерал переменной примитивного типа:

логический результат = true;
char capitalC = 'C';
байт b = 100;
короткий s = 10000;
int i = 100000;
 
целочисленных литералов

Целочисленный литерал имеет тип длиной , если он заканчивается буквой L или l ; в противном случае он имеет тип и . Рекомендуется использовать заглавную букву L , потому что строчную букву l трудно отличить от цифры 1 .

Значения целочисленных типов байт , short , int и long могут быть созданы из литералов и . Значения типа длиной , превышающие диапазон от до , могут быть созданы из литералов длиной и . Целочисленные литералы могут быть выражены этими системами счисления:

  • Десятичное число: основание 10, цифры которого состоят из чисел от 0 до 9; это система счисления, которую вы используете каждый день
  • Шестнадцатеричный: основание 16, цифры которого состоят из цифр от 0 до 9 и букв от A до F
  • Binary: Base 2, чьи цифры состоят из чисел 0 и 1 (вы можете создавать двоичные литералы в Java SE 7 и более поздних версиях)

Для программирования общего назначения десятичная система, вероятно, будет единственной системой счисления, которую вы когда-либо будете использовать.Однако, если вам нужно использовать другую систему счисления, в следующем примере показан правильный синтаксис. Префикс 0x обозначает шестнадцатеричный код, а 0b обозначает двоичный код:

// число 26 в десятичном виде
int decVal = 26;
// число 26, в шестнадцатеричном
int hexVal = 0x1a;
// число 26, в двоичном
int binVal = 0b11010;
 
Литералы с плавающей точкой

Литерал с плавающей точкой имеет тип с плавающей запятой , если он заканчивается буквой F или f ; в противном случае его тип двойной , и он может факультативно заканчиваться буквой D или d .

Типы с плавающей запятой ( с плавающей запятой и с двойным ) также могут быть выражены с помощью E или e (для научной записи), F или f (32-разрядный литерал с плавающей запятой) и D или d (64-разрядный двойной литерал; это по умолчанию и по соглашению опущено).

двойной d1 = 123,4;
// то же значение, что и d1, но в научной нотации
двойной d2 = 1,234e2;
float f1 = 123,4f;
 
Символьные и строковые литералы

Литералы типов char и String могут содержать любые символы Unicode (UTF-16).Если ваш редактор и файловая система позволяют это, вы можете использовать такие символы прямо в своем коде. Если нет, вы можете использовать «Unicode escape», например, '\ u0108' (заглавная C с круговым сплетением) или "S \ u00ED Se \ u00F1 или" (Sí Señor по-испански). Всегда используйте «одинарные кавычки» для литералов с символом и «двойные кавычки» для литералов String . Экранирующие последовательности Unicode могут использоваться в других местах программы (например, в именах полей), а не только в литералах char или String .

Язык программирования Java также поддерживает несколько специальных escape-последовательностей для литералов char и String : \ b (backspace), \ t (табуляция), \ n (перевод строки), \ f (подача формы), \ r (возврат каретки), \ " (двойная кавычка), \ ' (одинарная кавычка) и \ (обратная косая черта).

Существует также специальный литерал null , который можно использовать в качестве значения для любого ссылочного типа. null может быть назначен любой переменной, кроме переменных примитивных типов. С тестом на наличие , равным нулю , мало что можно сделать. Поэтому null часто используется в программах в качестве маркера для указания того, что какой-то объект недоступен.

Наконец, есть также особый тип литерала, называемый литералом класса , сформированный путем взятия имени типа и добавления « .class» ; например, String.class .Это относится к объекту (типа , класс ), который представляет сам тип.

Использование символов подчеркивания в числовых литералах

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

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

В следующем примере показаны другие способы использования подчеркивания в числовых литералах:

long creditCardNumber = 1234_5678_9012_3456L;
long socialSecurityNumber = 999_99_9999L;
число с плавающей запятой = 3.14_15F;
long hexBytes = 0xFF_EC_DE_5E;
long hexWords = 0xCAFE_BABE;
long maxLong = 0x7fff_ffff_ffff_ffffL;
nybbles байта = 0b0010_0101;
длинные байты = 0b11010010_01101001_10010100_10010010;
 

Подчеркивание можно ставить только между цифрами; Вы не можете разместить подчеркивание в следующих местах:

  • В начале или в конце числа
  • Рядом с десятичной запятой в литерале
  • До суффикса F или L
  • В позициях, где ожидается строка цифр

Следующие примеры демонстрируют допустимые и недействительные размещения подчеркивания (которые выделены) в числовых литералах:

//  Invalid: невозможно поставить подчеркивание 
//  рядом с десятичной точкой 
float pi1 = 3_.1415F;
//  Invalid: невозможно поставить подчеркивание 
//  рядом с десятичной точкой 
float pi2 = 3._1415F;
//  Invalid: невозможно поставить подчеркивание 
//  до суффикса L 
long socialSecurityNumber1 = 999_99_9999_L;

// ОК (десятичный литерал)
int x1 = 5_2;
//  Invalid: невозможно поставить подчеркивание 
//  В конце литерала 
int x2 = 52_;
// ОК (десятичный литерал)
int x3 = 5_______2;

//  Invalid: невозможно поставить подчеркивание 
//  с префиксом 0x radix 
int x4 = 0_x52;
//  Invalid: невозможно поставить подчеркивание 
//  в начале числа 
int x5 = 0x_52;
// ОК (шестнадцатеричный литерал)
int x6 = 0x5_2;
//  Invalid: невозможно поставить подчеркивание 
//  в конце номера 
int x7 = 0x52_;
 
,