Типы данных, литералы и переменные

[Marley]

Типы данных, литералы и переменные

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


О значении типов данных

Типы данных имеют особенное значение в С#, поскольку это строго типизированный язык. Это означает, что все операции подвергаются строгому контролю со стороны компилятора на соответствие типов, причем недопустимые операции не компилируются. Следовательно, строгий контроль типов позволяет исключить ошибки и повысить надеж¬ность программ. Для обеспечения контроля типов все переменные, выражения и значения должны принадлежать к определенному типу. Более того, тип значения определяет те операции, которые разрешается выполнять над ним. Операция, разрешенная для одного типа данных, может оказаться недопустимой для другого.

[Marley]

Типы значений в С#

В С# имеются две общие категории встроенных типов данных: типы значений и ссылочные типы. Они отличаются по содержимому переменной. Если переменная относится к типу значения, то она содержит само значение, например 3,1416 или 212. А если переменная относится к ссылочному типу, то она содержит ссылку на значение. Наиболее распространенным примером использования ссылочного типа является класс, но о классах и ссылочных типах речь пойдет далее в этой книге. А здесь рассматриваются типы значений.

Основу языка С# составляют 13 типов значений, перечисленных в табл. Все они называются простыми типами, поскольку состоят из единственного значения. (Иными словами, они не состоят из двух или более значений.) Они составляют основу системы типов С#, предоставляя простейшие, низкоуровневые элементы данных, которыми можно оперировать в программе. Простые типы данных иногда еще называют примитивными.

Типы значений в C#

Тип	Значение
bool	Логический, предоставляет два значения: "истина" или "ложь"
byte	8-разрядный целочисленный без знака
char	Символьный
decimal	Десятичный (для финансовых расчетов)
double	С плавающей точкой двойной точности
float	С плавающей точкой одинарной точности
int	Целочисленный
long	Длинный целочисленный
sbyte	8-разрядный целочисленный со знаком
short	Короткий целочисленный
uint	Целочисленный без знака
ulong	Длинный целочисленный без знака
ushort	Короткий целочисленный без знака

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

На заметку! Помимо простых типов, в С# определены еще три категории типов значений: перечисления, структуры и обнуляемые типы. Все они рассматриваются далее.

[Marley]

Целочисленные типы

В С# определены девять целочисленных типов: char, byte, sbyte, short, ushort, int, uint, long и ulong. Но тип char применяется, главным образом, для представления символов и поэтому рассматривается далее в этой главе. Остальные восемь целочисленных типов предназначены для числовых расчетов. Ниже представлены их диапазон представления чисел и разрядность в битах.

Тип	Разрядность в битах	Диапазон представления чисел
byte	8	0-255
sbyte	8	-128-127
short	16	-32 768-32 767
ushort	16	0-65 535
int	32	-2 147 483 648-2 147 483 647
uint	32	0-4 294 967 295
long	64	-9 223 372 036 854 775 808-9 223 372 036 854 775 807
ulong	64	0-18 446 744 073 709 551 615

Как следует из приведенной выше таблицы, в С# определены оба варианта различных целочисленных типов: со знаком и без знака. Целочисленные типы со знаком отличаются от аналогичных типов без знака способом интерпретации старшего разряда целого числа. Так, если в программе указано целочисленное значение со знаком, то компилятор С# сгенерирует код, в котором старший разряд целого числа используется в качестве флага знака. Число считается положительным, если флаг знака равен 0, и отрицательным, если он равен 1. Отрицательные числа практически всегда представляются методом дополнения до двух, в соответствии с которым все двоичные разряды отрицательного числа сначала инвертируются, а затем к этому числу добавляется 1.

Целочисленные типы со знаком имеют большое значение для очень многих алгоритмов, но по абсолютной величине они наполовину меньше своих аналогов без знака. Вот как, например, выглядит число 32 767 типа short в двоичном представлении:

0111111111111111

Если установить старший разряд этого числа равным 1, чтобы получить значение со знаком, то оно будет интерпретировано как -1, принимая во внимание формат дополнения до двух. Но если объявить его как значение типа ushort, то после установки в 1 старшего разряда оно станет равным 65 535.

Вероятно, самым распространенным в программировании целочисленным типом является тип int. Переменные типа int нередко используются для управления циклами, индексирования массивов и математических расчетов общего назначения. Когда же требуется целочисленное значение с большим диапазоном представления чисел, чем у типа int, то для этой цели имеется целый ряд других целочисленных типов. Так, если значение нужно сохранить без знака, то для него можно выбрать тип uint, для больших значений со знаком — тип long, а для больших значений без знака — тип ulong. В качестве примера ниже приведена программа, вычисляющая расстояние от Земли до Солнца в дюймах. Для хранения столь большого значения в ней используется переменная типа long.

Код: Выделить всё

// Вычислить расстояние от Земли до Солнца в дюймах.
using System;
class Inches
{
    static void Main()
    {
        long inches; long miles;
        miles = 93000000; // 93 000 000 миль до Солнца // 5 280 футов в миле, 12 дюймов в футе.
        inches = miles * 5280 * 12;
        Console.WriteLine("Расстояние до Солнца: " + inches + " дюймов.");
    }
}
 

Вот как выглядит результат выполнения этой программы:




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

Самыми мелкими целочисленными типами являются byte и sbyte. Тип byte представляет целые значения без знака в пределах от 0 до 255. Переменные типа byte особенно удобны для обработки исходных двоичных данных, например байтового потока, поступающего от некоторого устройства. А для представления мелких целых значений со знаком служит тип sbyte. Ниже приведен пример программы, в которой переменная типа byte используется для управления циклом, где суммируются числа от 1 до 100.

Код: Выделить всё

// Использовать тип byte.
using System;
class Ose_byte
{
    static void Main()
    {
        byte x;
        int sum;
        sum = 0;
        for (x = 1; x <= 100; x++) sum = sum + x;
        Console.WriteLine(
            "Сумма чисел от 1 до 100 равна " + sum);
    }
} 

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



В приведенном выше примере программы цикл выполняется только от 1 до 100, что не превышает диапазон представления чисел для типа byte, и поэтому для управления этим циклом не требуется переменная более крупного типа.

Если требуется целое значение, большее, чем значение типа byte или sbyte, но меньшее, чем значение типа int или uint, то для него можно выбрать тип short или ushort.

[Marley]

Типы для представления чисел с плавающей точкой

Типы с плавающей точкой позволяют представлять числа с дробной частью. В С# имеются две разновидности типов данных с плавающей точкой: float и double. Они представляют числовые значения с одинарной и двойной точностью соответственно. Так, разрядность типа float составляет 32 бита, что приближенно соответствует диапазону представления чисел от 5Е-45 до 3,4Е+38. А разрядность типа double составляет 64 бита, что приближенно соответствует диапазону представления чисел от 5Е-324 до 1.7E+308.
В программировании на С# чаще применяется тип double, в частности, потому, что во многих математических функциях из библиотеки классов С#, которая одновременно является библиотекой классов для среды .NET Framework, используются числовые значения типа double. Например, метод Sqrt (), определенный в библиотеке классов System.Math, возвращает значение типа double, которое представляет собой квадратный корень из аргумента типа double, передаваемого данному методу. В приведенном ниже примере программы метод Sqrt () используется для вычисления радиуса окружности по площади круга.

Код: Выделить всё

// Определить радиус окружности по площади круга.
using System;
class FindRadius
{
    static void Main()
    {
        Double r;
        Double area;
        area = 10.0;
        r = Math.Sqrt(area / 3.1416);
        Console.WriteLine("Радиус равен " + r);
    }
} 

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



В приведенном выше примере программы следует обратить внимание на вызов метода Sqrt (). Как упоминалось выше, метод Sqrt () относится к классу Math, поэтому в его вызове имя Math предшествует имени самого метода. Аналогичным образом имя класса Console предшествует имени метода WriteLine () в его вызове. При вызове некоторых, хотя и не всех, стандартных методов обычно указывается имя их класса, как показано в следующем примере.
В приведенном ниже примере программы демонстрируется применение нескольких тригонометрических функций, которые относятся к классу Math и входят в стандартную библиотеку классов С#. Они также оперируют данными типа double. В этом примере на экран выводятся значения синуса, косинуса и тангенса угла, измеряемого в пределах от 0,1 до 1,0 радиана.

Код: Выделить всё

// Продемонстрировать применение тригонометрических // функций.
using System;
class Trigonometry
{
    static void Main()
    {
        Double theta; // угол в радианах
        for (theta = 0.1;
             theta <= 1.0;
             theta = theta + 0.1)
        {
            {
                Console.WriteLine("Синус угла " + theta +
                                  "   равен " + Math.Sin(theta));
                Console.WriteLine("Косинус угла " + theta +
                                  "   равен " + Math.Cos(theta));
                Console.WriteLine("Тангенс угла " + theta +
                                  "   равен " + Math.Tan(theta));
                Console.WriteLine();
            }
        }
    }
}

 

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



Для вычисления синуса, косинуса и тангенса угла в приведенном выше примере были использованы стандартные методы Math. Sin (), Math. Cos () и Math. Tan (). Как и метод Math. Sqrt (), эти тригонометрические методы вызываются с аргументом типа double и возвращают результат того же типа. Вычисляемые углы должны быть указаны в радианах.

[Marley]

Десятичный тип данных

Вероятно, самым интересным среди всех числовых типов данных в С# является тип decimal, который предназначен для применения в финансовых расчетах. Этот тип имеет разрядность 128 бит для представления числовых значений в пределах от 1Е-28 до 7,9Е+28. Вам, вероятно, известно, что для обычных арифметических вычислений с плавающей точкой характерны ошибки округления десятичных значений. Эти ошибки исключаются при использовании типа decimal, который позволяет представить числа с точностью до 28 (а иногда и 29) десятичных разрядов. Благодаря тому что этот тип данных способен представлять десятичные значения без ошибок округления, он особенно удобен для расчетов, связанных с финансами.

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

Код: Выделить всё

// Использовать тип decimal для расчета скидки.
using System;
class UseDecimal
{
    static void Main()
    {
        decimal price;
        decimal discount;
        decimal discounted_price;
        // Рассчитать цену со скидкой, 
        price = 19.95m;
        discount = 0.15m; // норма скидки составляет 15%
        discounted_price = price - (price * discount);
        Console.WriteLine("Цена со скидкой: $" + discounted_price);
    }
}
 

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




Обратите внимание на то, что значения констант типа decimal в приведенном выше примере программы указываются с суффиксом m. Дело в том, что без суффикса m эти значения интерпретировались бы как стандартные константы с плавающей точкой, которые несовместимы с типом данных decimal. Тем не менее переменной типа decimal можно присвоить целое значение без суффикса m, например 10. (Подробнее о числовых константах речь пойдет далее в этой главе.)

Рассмотрим еще один пример применения типа decimal. В этом примере рассчитывается будущая стоимость капиталовложений с фиксированной нормой прибыли в течение ряда лет.

Код: Выделить всё

/*
Применить тип decimal для расчета будущей стоимости капиталовложений. */
using System;
class FutVal
{
    static void Main()
    {
        decimal amount; decimal rate_of_return; int years, i;
        amount = 1000.0M; rate_of_return = 0.07M; years = 10;
        Console.WriteLine("Первоначальные капиталовложения: $" + amount); Console.WriteLine("Норма прибыли: " + rate_of_return); Console.WriteLine("В течение" + years + " лет");
        for (i = 0; i < years; i++)
            amount = amount + (amount * rate_of_return);
        Console.WriteLine("Будущая стоимость равна $" + amount);
    }
}
 

Вот как выглядит результат выполнения этой программы:



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

[Marley]

Символы

В С# символы представлены не 8-разрядным кодом, как во многих других языках программирования, например С++, а 16-разрядным кодом, который называется уникодом (Unicode). В уникоде набор символов представлен настолько широко, что он охватывает символы практически из всех естественных языков на свете. Если для многих естественных языков, в том числе английского, французского и немецкого, характерны относительно небольшие алфавиты, то в ряде других языков, например китайском, употребляются довольно обширные наборы символов, которые нельзя представить 8-разрядным кодом. Для преодоления этого ограничения в С# определен тип char, представляющий 16-разрядные значения без знака в пределах от 0 до 65 535. При этом стандартный набор символов в 8-разрядном коде ASCII является подмножеством уникода в пределах от 0 до 127. Следовательно, символы в коде ASCII по-прежнему остаются действительными в С#.

Для того чтобы присвоить значение символьной переменной, достаточно заключить это значение (т.е. символ) в одинарные кавычки. Так, в приведенном ниже фрагменте кода переменной ch присваивается символ X.

Код: Выделить всё

char ch;
ch = 'X';

Значение типа char можно вывести на экран с помощью метода WriteLine (). Например, в следующей строке кода на экран выводится значение переменной ch:

Код: Выделить всё

Console.WriteLine("Значение ch равно: " + ch) ;

Несмотря на то что тип char определен в С# как целочисленный, его не следует путать со всеми остальными целочисленными типами. Дело в том, что в С# отсутствует автоматическое преобразование символьных значений в целочисленные и обратно. Например, следующий фрагмент кода содержит ошибку:

Код: Выделить всё

char ch;
ch = 88; // ошибка, не выйдет

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

[Marley]

Логический тип данных

Тип bool представляет два логических значения: "истина" и "ложь". Эти логические значения обозначаются в С# зарезервированными словами true и false соответственно. Следовательно, переменная или выражение типа bool будет принимать одно из этих логических значений. Кроме того, в С# не определено взаимное преобразование логических и целых значений. Например, 1 не преобразуется в значение true, а 0 — в значение false.

В приведенном ниже примере программы демонстрируется применение типа bool.

Код: Выделить всё

// Продемонстрировать применение типа bool.
using System;
class BoolDemo
{
    static void Main()
    {
        bool b;
        b = false;
        Console.WriteLine("b равно " + b); b = true;
        Console.WriteLine("b равно " + b);
        // Логическое значение может управлять // оператором if.
        if (b) Console.WriteLine("Выполняется."); b = false;
        if (b) Console.WriteLine("He выполняется.");
        // Результатом выполнения оператора отношения
        // является логическое значение.
        Console.WriteLine("10 > 9 равно " + (10 > 9));
    }
}
 

Эта программа дает следующий результат:



В приведенной выше программе обнаруживаются три интересных свойства. Во-первых, при выводе логического значения типа bool с помощью метода WriteLine () на экране появляется значение "True" или "False". Во-вторых, самого значения переменной типа bool достаточно для управления оператором if. Для этого не нужно, например, записывать оператор if следующим образом:

Код: Выделить всё

if (b == true)…

И в-третьих, результатом выполнения оператора отношения является логическое значение. Именно поэтому в результате вычисления выражения 10 > 9 на экран выводится значение "True." Кроме того, выражение 10 > 9 следует заключить в скобки, поскольку оператор + имеет более высокий приоритет, чем оператор >.

[Marley]

Другие возможности вывода

До сих пор при выводе с помощью метода WriteLine () данные отображались в формате, используемом по умолчанию. Но в среде .NET Framework определен достаточно развитый механизм форматирования, позволяющий во всех деталях управлять выводом данных. Форматированный ввод-вывод подробнее рассматривается далее в этой книге, а до тех пор полезно ознакомиться с некоторыми возможностями форматирования. Они позволяют указать, в каком именно виде следует выводить значения с помощью метода WriteLine (). Благодаря этому выводимый результат выглядит более привлекательно. Следует, однако, иметь в виду, что механизм форматирования поддерживает намного больше возможностей, а не только те, которые рассматриваются в этом разделе.

При выводе списков данных в предыдущих примерах программ каждый элемент списка приходилось отделять знаком +, как в следующей строке:

Код: Выделить всё

Console .WriteLine ("Вы заказали " + 2 + " предмета по цене $" + 3 + " каждый.");

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

Код: Выделить всё

Console.WriteLine("Деление 10/3 дает: " + 10.0/3.0);

который выводит следующий результат:

Код: Выделить всё

Деление 10/3 дает: 3.33333333333333

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

Для управления форматированием числовых данных служит другая форма метода WriteLine (), позволяющая встраивать информацию форматирования, как показано ниже.

Код: Выделить всё

WriteLine("форматирующая строка ", arg0, argl, ... , argsN);

В этой форме аргументы метода WriteLine () разделяются запятой, а не знаком +. А форматирующая строка состоит из двух элементов: обычных печатаемых символов, предназначенных для вывода в исходном виде, а также спецификаторов формата. Последние указываются в следующей общей форме:

Код: Выделить всё

{argnum, width: fmt)

где argnum — номер выводимого аргумента, начиная с нуля; width — минимальная ширина поля; fmt — формат. Параметры width и fmt являются необязательными.

Если во время выполнения в форматирующей строке встречается спецификатор формата, то вместо него подставляется и отображается соответствующий аргумент, обозначаемый параметром argnum. Таким образом, местоположение спецификатора формата в форматирующей строке определяет место отображения соответствующих данных. Параметры width и fmt указывать необязательно. Это означает, что в своей простейшей форме спецификатор формата обозначает конкретный отображаемый аргумент. Например, спецификатор {0} обозначает аргумент arg0, спецификатор {1} — аргумент arg1 и т.д.

Начнем с самого простого примера. При выполнение оператора

Код: Выделить всё

Console.WriteLine ("В феврале {0} или {1} дней.", 28, 29);

получается следующий результат:

Код: Выделить всё

В феврале 28 или 29 дней

Как видите, значение 28 подставляется вместо спецификатора {0}, а значение 29 — вместо спецификатора {1}. Следовательно, спецификаторы формата обозначают место в строке, где отображаются соответствующие аргументы (в данном случае — значения 28 и 29). Кроме того, обратите внимание на то, что дополнительные значения разделяются запятой, а не знаком +.

Ниже приведен видоизмененный вариант предыдущего оператора, в котором указывается ширина полей.

Код: Выделить всё

Console.WriteLine ("В феврале (0,10} или (1,5} дней.", 28, 29);

Выполнение этого оператора дает следующий результат:

Код: Выделить всё

В феврале 28 или      29 дней.

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

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

Код: Выделить всё

// Применить команды форматирования.
using System;
class DisplayOptions
{
    static void Main()
    {
        int i;
        Console.WriteLine("Число\tКвадрат\tКуб");
        for (i = 1; i < 10; i++) Console.WriteLine("{0}\t{1}\t{2}", i, i * i, i * i * i);
    }
}
} 

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




В приведенных выше примерах сами выводимые значения не форматировались. Но ведь основное назначение спецификаторов формата — управлять внешним видом выводимых данных. Чаще всего форматированию подлежат следующие типы данных: с плавающей точкой и десятичный. Самый простой способ указать формат данных — описать шаблон, который будет использоваться в методе WriteLine (). Для этого указывается образец требуемого формата с помощью символов #, обозначающих разряды чисел. Кроме того, можно указать десятичную точку и запятые, разделяющие цифры. Ниже приведен пример более подходящего вывода результата деления 10 на 3.

Код: Выделить всё

Console.WriteLine("Деление 10/3 дает: {0:#.##}", 10.0/3.0);

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

Код: Выделить всё

Деление 10/3 дает: 3.33

В данном примере шаблон #.## указывает методу WriteLineO отобразить два десятичных разряда в дробной части числа. Следует, однако, иметь в виду, что метод WriteLine () может отобразить столько цифр слева от десятичной точки, сколько потребуется для правильной интерпретации выводимого значения.

Рассмотрим еще один пример. Оператор

Код: Выделить всё

Console.WriteLine("{0:###,###.##}", 123456.56);

дает следующий результат:

Код: Выделить всё

123,456.56

Для вывода денежных сумм рекомендуется использовать спецификатор формата С.

Например:

Код: Выделить всё

decimal balance;
balance = 12323.09m;
Console.WriteLine("Текущий баланс равен (0:C}", balance);

Результат выполнения этого фрагмента кода выводится в формате денежных сумм, указываемых в долларах США.

Код: Выделить всё

Текущий баланс равен $12,323.09

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

Код: Выделить всё

// Использовать спецификатор формата С для вывода 
// результата в местной валюте.
using System;
class UseDecimal
{
    static void Main()
    {
        decimal price;
        decimal discount;
        decimal discounted_price;

        // рассчитать цену со скидкой, 
        price = 19.95m;
        discount = 0.15m; // норма скидки составляет 15% 
        discounted_price = price - (price * discount);

        Console.WriteLine("Цена со скидкой: {0:C}", discounted_price);
    }
} 

Вот как теперь выглядит результат выполнения этой программы:

[Marley]

Литералы

В С# литералами называют постоянные значения, представленные в удобной для восприятия форме. Например, число 100 является литералом. Сами литералы и их назначение настолько понятны, что они применялись во всех предыдущих примерах программ без всяких пояснений. Но теперь настало время дать им формальное объяснение.

В С# литералы могут быть любого простого типа. Представление каждого литерала зависит от конкретного типа. Как пояснялось ранее, символьные литералы заключаются в одинарные кавычки. Например, 'а' и являются символьными литералами.

Целочисленные литералы указываются в виде чисел без дробной части. Например, 10 и -100 — это целочисленные литералы. Для обозначения литералов с плавающей точкой требуется указывать десятичную точку и дробную часть числа. Например, 11.123 — это литерал с плавающей точкой. Для вещественных чисел с плавающей точкой в С# допу¬скается также использовать экспоненциальное представление.

У литералов также должен быть конкретный тип, поскольку С# является строго типизированным языком. В этой связи возникает естественный вопрос: к какому типу следует отнести числовой литерал, например 2,123987 или 0.23? К счастью, для ответа на этот вопрос в С# установлен ряд простых для соблюдения правил.

Во-первых, у целочисленных литералов должен быть самый мелкий целочисленный тип, которым они могут быть представлены, начиная с типа int. Таким образом, у целочисленных литералов может быть один из следующих типов: int, uint, long или ulong в зависимости от значения литерала. И во-вторых, литералы с плавающей точкой относятся к типу double.

Если вас не устраивает используемый по умолчанию тип литерала, можете явно указать другой его тип с помощью суффикса. Так, для указания типа long к литералу присоединяется суффикс l или L. Например, 12 — это литерал типа int, a 12L — литерал типа long. Для указания целочисленного типа без знака к литералу присоединяется суффикс и или U. Следовательно, 100 — это литерал типа int, a 100U — литерал типа uint. А для указания длинного целочисленного типа без знака к литералу присоединяется суффикс ul или UL. Например, 984375UL — это литерал типа ulong.

Кроме того, для указания типа float к литералу присоединяется суффикс F или f. Например, 10.19F — это литерал типа float. Можете даже указать тип double, присоединив к литералу суффикс d или D, хотя это излишне. Ведь, как упоминалось выше, по умолчанию литералы с плавающей точкой относятся к типу double.

И наконец, для указания типа decimal к литералу присоединяется суффикс m или М. Например, 9.95М — это десятичный литерал типа decimal.

Несмотря на то, что целочисленные литералы образуют по умолчанию значения типа int, uint, long или ulong, их можно присваивать переменным типа byte, sbyte, short или ushort, при условии, что присваиваемое значение может быть представлено целевым типом.


Шестнадцатеричные литералы

Вам, вероятно, известно, что в программировании иногда оказывается проще пользоваться системой счисления по основанию 16, чем по основанию 10. Система счисления по основанию 16 называется шестнадцатеричной. В ней используются числа от 0 до 9, а также буквы от А до F, которыми обозначаются десятичные числа 10, 11, 12,13, 14 и 15. Например, десятичному числу 16 соответствует шестнадцатеричное число 10. Вследствие того что шестнадцатеричные числа применяются в программировании довольно часто, в С# разрешается указывать целочисленные литералы в шестнадцатеричном формате. Шестнадцатеричные литералы должны начинаться с символов 0х, т.е. нуля и последующей латинской буквы "икс". Ниже приведены некоторые примеры шестнадцатеричных литералов.

Код: Выделить всё

count = OxFF;   // 255 в десятичной системе
incr = 0x1а;     // 26 в десятичной системе

[Marley]

Управляющие последовательности символов

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

Таблица Управляющие последовательности символов

Управляющая последовательность	Описание
\a	Звуковой сигнал (звонок)
\b	Возврат на одну позицию
\f	Перевод страницы (переход на новую страницу)
\n	Новая строка (перевод строки)
\r	Возврат каретки
\t	Горизонтальная табуляция
\v	Вертикальная табуляция
\0	Пустой символ

Например, в следующей строке кода переменной ch присваивается символ табуляции:

Код: Выделить всё

ch = '\t';

А в приведенном ниже примере кода переменной ch присваивается символ одинарной кавычки.

Код: Выделить всё

ch = '\'';