Sbyte c что это
Язык C# позволяет Вам определить два типа переменных: типы значений (value types) и типы указателей (reference types). Value types хранят актуальное значение переменной, а reference types хранят ссылку на переменную, которая хранится где-то в памяти. Все точно также, как в старом добром C и C++.
Типы value types размещаются в стеке и доступны во многих языках программирования. Типы reference types размещаются в куче (heap) и обычно представляют экземпляры класса (class instances).
[Предопределенные типы значений C# (predefined C# value types)]
sbyte: хранит 8-битное целое со знаком (signed integer). Символ s в sbyte означает, что переменная имеет знак (sign), и может быть положительной или отрицательной. Самое маленькое возможное значение может быть -128, самое большое значение 127.
byte: хранит 8-битное беззнаковое целое (unsigned integer). В отличие от переменной sbyte переменная byte не имеет знака и может хранить только положительные значения. Самое маленькое возможное значение может быть 0, самое большое значение 255.
short: хранит 16-битное целое со знаком (signed integer). Знак в sbyte означает, что переменная может быть положительной или отрицательной. Самое маленькое возможное значение может быть -32768, самое большое значение 32767.
ushort: хранит 16-битное беззнаковое целое (unsigned integer). Символ u означает, что переменная не имеет знака (unsigned). В отличие от переменной short переменная ushort не имеет знака и может хранить только положительные значения. Самое маленькое возможное значение может быть 0, самое большое значение 65535.
int: хранит 32-битное целое со знаком. Наименьшее возможное значение -2147483648, наибольшее возможное значение 2147483647.
uint: хранит 32-битное беззнаковое целое. Символ u в uint означает, что число не имеет знака. Наименьшее возможное значение 0, наибольшее 4294967295.
long: хранит 64-битное целое со знаком. Наименьшее возможное значение -9223372036854775808, наибольшее возможное значение 9223372036854775807.
char: хранит 16-битный символ Unicode. Наименьшее возможное значение для символа Unicode равно 0, наибольшее 65535.
float: хранит 32-битное число с плавающей запятой, со знаком. Наименьшее возможное значение примерно 1.5 * 10 в -45 степени, наибольшее примерно 3.4 * 10 в 38 степени.
double: хранит 64-битное число с плавающей запятой, со знаком. Наименьшее возможное значение примерно 5 * 10 в -324 степени, наибольшее примерно 1.7 * 10 в 308 степени.
decimal: хранит 128-битное число с плавающей запятой, со знаком. Переменные типа decimal хорошо подходят для финансовых вычислений.
bool: хранит одно из двух возможных значений: true или false. Использование типа bool — одна из областей, где C# отличается от наследия C и С++. В языках C и C++ целое число 0 было синонимом false, и любое ненулевое значение было синонимом true. Однако в C# тип bool не является синонимом целого типа. Вы не можете сконвертировать переменную целого типа в эквивалентную переменную bool. Если Вам нужно работать с переменными, которые представляют условия true или false, используйте в C# только переменную типа bool, и никак не целочисленную переменную.
[Предопределенные типы указателей C# (predefined C# reference types)]
string: представляет строку символов Unicode. Позволяет просто манипулировать строками и назначать их. Строки не являются мутируемыми (они immutable), т. е. будучи созданными, они не могут быть модифицированы. Так например, если Вы попытаетесь модифицировать строку (наподобие приклеить к ней другую строку), то в реальности будет создан новый объект строки, который будет содержать результирующую строку.
object: представляет тип общего назначения (general purpose type). В C# все предопределенные типы и заданные пользователем типы наследуются от типа object или класса System.Object.
Правильное использование корректных типов данных позволяет разработчикам максимально использовать возможности языка C#, однако это требует некоторого времени на изучение для тех, кто ранее использовал другие языки программирования. Для получения более подробной информации по каждому типу данных обратитесь на официальный сайт Microsoft.
Sbyte c что это
Все, что необходимо начинающему и опытному программисту
Типы данных.
В этом разделе мы поговорим о типах данных языка C#. Не скроем, что вы найдете здесь массу сюрпризов. Начнем с того, что все встроенные типы данных являются синонимами для соответствующих структур (в некоторых случаях классов), определенных в пространстве имен System. Это означает, что каждая объявленная вами переменная является объектом соответствующей структуры или класса (подробнее о структурах и классах читайте в следующих уроках). Например, каждый числовой тип данных имеет поля MinValue и MaxValue, хранящие соответственно минимальное и максимальное возможные значения для данного типа (см. практические примеры в этом уроке).
Представляем вашему вниманию таблицу, содержащую встроенные типы данных языка C# и соответствующие им структуры или классы пространства имен System.
| C# тип | .NET Framework тип | Количество бит | Суффикс, используемый в литералах | Описание |
|---|---|---|---|---|
| bool | System.Boolean | 8 | — | Логический тип, может принимать только два значения: true и false |
| byte | System.Byte | 8 | — | Беззнаковый байт |
| sbyte | System.SByte | 8 | — | Знаковый байт |
| char | System.Char | 16 | — | Символ Unicode |
| decimal | System.Decimal | 128 | m, M | Десятичное число с фиксированной точностью |
| double | System.Double | 64 | d, D | Число с плавающей запятой |
| float | System.Single | 32 | f, F | Число с плавающей запятой |
| int | System.Int32 | 32 | — | Целое знаковое число |
| uint | System.UInt32 | 32 | u, U | Целое беззнаковое число |
| long | System.Int64 | 64 | l, L | Целое знаковое число |
| ulong | System.UInt64 | 64 | ul, uL, UL, Ul, lu, lU, LU, Lu | Целое беззнаковое число |
| object | System.Object | — | — | Базовый тип данных, все остальные типы являются производными от него |
| short | System.Int16 | 16 | — | Целое знаковое число |
| ushort | System.UInt16 | 16 | — | Целое беззнаковое число |
| string | System.String | — | — | Строка символов Unicode |
Из перечисленных имен System.Object и System.String являются классами, остальные структурами. Поэтому объекты типа string и object называются ссылочными типами, а остальные структурными. Ссылочные и структурные типы будут подробно рассмотрены в следующих уроках. В этом уроке мы всего лишь отметим основную разницу между ними.
Объект ссылочного типа создается в куче, а объект структурного типа создается в стеке. В том случае, если структурный тип присваивается объекту типа object, в куче создается временный объект, имитирующий поведение ссылочного. В этот временный объект копируются данные из структурного, а сам объект помечается специальной отметкой, чтобы система знала к какому типу он относится. Этот процесс называется упаковкой (boxing), обратный процесс называется распаковкой (unboxing).
Кстати, в языке C# отсутствует понятие указателя .
Приведение типов.
Неявно приводить можно:
| Тип данных | неявно приводится к |
|---|---|
| sbyte | short, int, long, float, double, decimal |
| byte | short, ushort, int, uint, long, ulong, float, double, decimal |
| short | int, long, float, double, decimal |
| ushort | int, uint, long, ulong, float, double, decimal |
| int | long, float, double, decimal |
| uint | long, ulong, float, double, decimal |
| long | float, double, decimal |
| ulong | float, double, decimal |
| char | ushort, int, uint, long, ulong, float, double, decimal |
| float | double |
****** константы типа int можно присваивать переменным типов sbyte, byte, short, ushort, uint, или ulong, в случае, если они могут их «съесть». ******
Явно приводить нужно:
| Тип данных | явно приводится к |
|---|---|
| sbyte | byte, ushort, uint, ulong, char |
| byte | sbyte, char |
| short | sbyte, byte, ushort, uint, ulong, char |
| ushort | sbyte, byte, short, char |
| int | sbyte, byte, short, ushort, uint, ulong, char |
| uint | sbyte, byte, short, ushort, int, char |
| long | sbyte, byte, short, ushort, int, uint, ulong, char |
| ulong | sbyte, byte, short, ushort, int, uint, long, or char |
| char | sbyte, byte, short |
| float | sbyte, byte, short, ushort, int, uint, long, ulong, char, decimal |
| double | sbyte, byte, short, ushort, int, uint, long, ulong, char, float, decimal |
| decimal | sbyte, byte, short, ushort, int, uint, long, ulong, char, float, or double |
За более полной информацией можно, как всегда, обратиться в MSDN.
Библиотека программиста. 2009.
Администратор: admin@programmer-lib.ru
Sbyte c что это
При рассмотрении типов данных указывалось, какие значения может иметь тот или иной тип и сколько байт памяти он может занимать. В прошлой теме были расмотрены арифметические операции. Теперь применим операцию сложения к данным разных типов:
byte a = 4; int b = a + 70;
Результатом операции вполне справедливо является число 74, как и ожидается.
Но теперь попробуем применить сложение к двум объектам типа byte :
byte a = 4; byte b = a + 70; // ошибка
Здесь поменялся только тип переменной, которая получает результат сложения — с int на byte. Однако при попытке скомпилировать программу мы получим ошибку на этапе компиляции. И если мы работаем в Visual Studio, среда подчеркнет вторую строку красной волнистой линией, указывая, что в ней ошибка.
При операциях мы должны учитывать диапазон значений, которые может хранить тот или иной тип. Но в данном случае число 74, которое мы ожидаем получить, вполне укладывается в диапазон значений типа byte, тем не менее мы получаем ошибку.
Дело в том, что операция сложения (да и вычитания) возвращает значение типа int, если в операции участвуют целочисленные типы данных с разрядностью меньше или равно int (то есть типы byte, short, int). Поэтому результатом операции a + 70 будет объект, который имеет длину в памяти 4 байта. Затем этот объект мы пытаемся присвоить переменной b, которая имеет тип byte и в памяти занимает 1 байт.
И чтобы выйти из этой ситуации, необходимо применить операцию преобразования типов. Операция преобразования типов предполагает указание в скобках того типа, к которому надо преобразовать значение:
(тип_данных_в_который_надо_преобразовать)значение_для_преобразования;
Так, изменим предыдущий пример, применив операцию преобразования типов:
byte a = 4; byte b = (byte)(a + 70);
Сужающие и расширяющие преобразования
Преобразования могут быть сужающие (narrowing) и расширяющие (widening). Расширяющие преобразования расширяют размер объекта в памяти. Например:
byte a = 4; // 0000100 ushort b = a; // 000000000000100
В данном случае переменной типа ushort присваивается значение типа byte. Тип byte занимает 1 байт (8 бит), и значение переменной a в двоичном виде можно представить как:
00000100
Значение типа ushort занимает 2 байта (16 бит). И при присвоении переменной b значение переменной a расширяется до 2 байт
0000000000000100
То есть значение, которое занимает 8 бит, расширяется до 16 бит.
Сужающие преобразования, наоборот, сужают значение до типа меньшей разядности. Во втором листинге статьи мы как раз имели дело с сужающими преобразованиями:
ushort a = 4; byte b = (byte) a;
Здесь переменной b, которая занимает 8 бит, присваивается значение ushort, которое занимает 16 бит. То есть из 0000000000000100 получаем 00000100 . Таким образом, значение сужается с 16 бит (2 байт) до 8 бит (1 байт).
Явные и неявные преобразования
Неявные преобразования
В случае с расширяющими преобразованиями компилятор за нас выполнял все преобразования данных, то есть преобразования были неявными ( implicit conversion ). Такие преобразования не вызывают каких-то затруднений. Тем не менее стоит сказать пару слов об общей механике подобных преобразований.
Если производится преобразование от безнакового типа меньшей разрядности к безнаковому типу большой разрядности, то добавляются дополнительные биты, которые имеют значени 0. Это называется дополнение нулями или zero extension.
byte a = 4; // 0000100 ushort b = a; // 000000000000100
Если производится преобразование к знаковому типу, то битовое представление дополняется нулями, если число положительное, и единицами, если число отрицательное. Последний разряд числа содержит знаковый бит — 0 для положительных и 1 для отрицательных чисел. При расширении в добавленные разряды компируется знаковый бит.
Рассмотрим преобразование положительного числа:
sbyte a = 4; // 0000100 short b = a; // 000000000000100
Преобразование отрицательного числа:
sbyte a = -4; // 1111100 short b = a; // 111111111111100
Явные преобразования
При явных преобразованиях ( explicit conversion ) мы сами должны применить операцию преобразования (операция () ). Суть операции преобразования типов состоит в том, что перед значением указывается в скобках тип, к которому надо привести данное значение:
int a = 4; int b = 6; byte c = (byte)(a+b);
Расширяющие преобразования от типа с меньшей разрядностью к типу с большей разрядностью компилятор проводит неявно. Это могут быть следующие цепочки преобразований:
byte -> short -> int -> long -> decimal
short -> float -> double
Все безопасные автоматические преобразования можно описать следующей таблицей:
В какие типы безопасно преобразуется
short, ushort, int, uint, long, ulong, float, double, decimal
short, int, long, float, double, decimal
int, long, float, double, decimal
int, uint, long, ulong, float, double, decimal
long, float, double, decimal
long, ulong, float, double, decimal
float, double, decimal
float, double, decimal
ushort, int, uint, long, ulong, float, double, decimal
В остальных случаях следует использовать явные преобразования типов.
Также следует отметить, что несмотря на то, что и double, и decimal могут хранить дробные данные, а decimal имеет большую разрядность, чем double, но все равно значение double нужно явно приводить к типу decimal:
double a = 4.0; decimal b = (decimal)a;
Потеря данных и ключевое слово checked
Рассмотрим другую ситуацию, что будет, например, в следующем случае:
int a = 33; int b = 600; byte c = (byte)(a+b); Console.WriteLine(c); // 121
Результатом будет число 121, так число 633 не попадает в допустимый диапазон для типа byte, и старшие биты будут усекаться. В итоге получится число 121. Поэтому при преобразованиях надо это учитывать. И мы в данном случае можем либо взять такие числа a и b, которые в сумме дадут число не больше 255, либо мы можем выбрать вместо byte другой тип данных, например, int.
Однако ситуации разные могут быть. Мы можем точно не знать, какие значения будут иметь числа a и b. И чтобы избежать подобных ситуаций, в c# имеется ключевое слово checked :
try < int a = 33; int b = 600; byte c = checked((byte)(a + b)); Console.WriteLine(c); >catch (OverflowException ex)
При использовании ключевого слова checked приложение выбрасывает исключение о переполнении. Поэтому для его обработки в данном случае используется конструкция try. catch. Подробнее данную конструкцию и обработку исключений мы рассмотрим позже, а пока надо знать, что в блок try мы включаем действия, в которых может потенциально возникнуть ошибка, а в блоке catch обрабатываем ошибку.
Что такое Переменные в C#?
Переменные невероятно важны, так как позволяют хранить информацию и использовать её в дальнейшем. На самом старте может быть не понятно зачем вообще что-то записывать в переменную, если можно просто оперировать значениями без них. Тем не менее, понимание переменных придет немного позже, когда мы начнем создавать более сложные программы и нам потребуется хранить информацию в каком-либо месте.
Типы данных или же типы переменных в языке C# указываются перед названием самой переменной. От конкретного типа данных будет зависеть содержимое переменной. Если мы укажем что переменная с типом данных для целых чисел int , то в нее мы не сможем записать строку или число с точкой.
В ходе программы мы можем записывать новые значения в переменную, но тип данных должен оставаться неизменным:
float some_value = 2.95f; some_value = 6.9f; // Записали новое значениеРассмотрим основные примитивные типы значений:
Числовые типы данных
| Тип | Тип .NET | Размер | Байты | Минимум | Максимум |
| byte | Byte | 8-разрядное значение без знака; | 1 | 0 | 255 |
| sbyte | SByte | 8-разрядное значение без знака; | 1 | -128 | 127 |
| short | Int16 | 16-разрядное значение без знака; | 2 | -32 768 | 32 767 |
| ushort | Uint16 | 16-разрядное значение без знака; | 2 | 0 | 65 635 |
| int | Int32 | 32-разрядное значение без знака; | 4 | –2 147 483 648 | 2 147 483 647 |
| uint | Uint32 | 32-разрядное значение без знака; | 4 | 0 | 4 294 967 295 |
| long | Int64 | 64-разрядное значение без знака; | 16 | -9 223 372 036 854 775 808 | 9 223 372 036 854 775 807 |
| ulong | Uint64 | 64-разрядное значение без знака; | 16 | 0 | 18 446 744 073 709 551 615 |
Числовые (с плавающей точкой)
| Тип | Тип .NET | Размер | Байты | Минимум | Максимум |
| float | Single | 32-разрядное значение с плавающей точкой в стандарте IEEE. Точность 4 – 9 цифр; | 4 | ± 1,5 x 10 −45 | ± 3,4 x 10 38 |
| double | Double | 64-разрядное значение с плавающей точкой в стандарте IEEE. Точность 15 – 17 цифр; | 8 | ± 5,0 × 10 −324 | ± 1,7 × 10 308 |
| decimal | Decimal | 128-разрядное значение с плавающей точкой, повышенной точности. Точность 28 – 29 цифр; | 16 | ±1,0 x 10 -28 | ±7,9228 x 10 28 |
Символьные типы
| Тип | Тип .NET | Размер | Байты | Минимум | Максимум |
| char | Char | 16-разрядный символ Unicode (char ни- когда не представляет 8-разрядное значение, как в неуправляемом коде на С++); | 1 | false (0) | true (1) |
| string | String | Массив символов; | — | — | — |
| bool | Boolean | Логический оператор, принимает значения: true – истинна и false – ложь; | — | — | — |
- Буква “s” обозначает со знаком. То есть число может быть отрицательным.
- Буква “u” обозначает без знака.
Для создания переменной необходимо указать тип данных и назвать её как-угодно. Также можно сразу же добавить к ней значение:
int a = 0; // Добавление значения сразу byte c; // Создание переменной без значения short b, y = 342; // Создание нескольких переменныхДля вызова переменной вы можете просто обратиться к ней по имени. Чтобы записать данные в переменную с типом float или double необходимо после числа дописывать букву f или d соответсвенно.