[ «Современная версия 6 языка C# насчитывает около 60 операторов. Некоторые используются чаще, другие реже. В написанном в самом начале фрагменте кода присутствуют следующие ...»
C# Приложения
Операторы
Современная версия 6 языка C# насчитывает около 60 операторов.
Некоторые используются чаще, другие реже. В написанном в самом начале фрагменте кода присутствуют следующие операторы
x.y — доступ к членам.
f(x) — вызов функции.
x++ — постфиксный инкремент. Возвращает значение x. Обновляет значение x, увеличив на единицу.
x * y — умножение.
x / y — деление. Если операнды имеют целые числа, результатом является целочисленное значение, усеченное в сторону нуля (например, -7 / 2 есть -3).
x + y — сложение.
x – y — вычитание.
x < y — меньше чем (значение true, если x меньше y).
x > y — больше чем (значение true, если x больше y).
x <= y — меньше или равно.
x >= y — больше или равно.
x = y — назначение – значению x присваивается, или «назначается» значение y. Оператор возвращает значение x.
x += y — инкремент. Добавляет значение y к значению x, сохраняет результат в x и возвращает новое значение.
Встроенные типы
C# является строго типизированным языком. Тип переменной должен быть определен до присвоения ей значения, как показано в следующих примерах.
int a = 1;
string s = "Hello";
XmlDocument tempDocument = new XmlDocument();
Обратите внимание, что тип должен быть определен как для простых встроенных типов, таких как int, так и для сложных или пользовательских типов, таких как XmlDocument.
C# поддерживает следующие встроенные типы данных.
Тип данных Диапазон
byte 0..
255
sbyte -128.. 127
short -32,768.. 32,767
ushort 0..
65,535
int -2,147,483,648.. 2,147,483,647
uint 0..
4,294,967,295
long -9,223,372,036,854,775,808.. 9,223,372,036,854,775,807
ulong 0..
18,446,744,073,709,551,615
float -3,402823e38.. -3,402823e38..
double -1,79769313486232e308.. 1,79769313486232e308
decimal -79228162514264337593543950335.. 79228162514264337593543950335
char Символ Юникода.
string Строка символов Юникода.
bool true или false
object Объект.
Эти типы данных называются псевдонимами для предопределенных типов в пространстве имен System. Они перечислены в разделе Таблица встроенных типов (Справочник по C#).
В приведенной ниже таблице представлены ключевые слова для встроенных типов C#, которые являются псевдонимами предопределенных типов в пространстве имен System.
Тип C#.Тип NET Framework
boolSystem.Boolean
byteSystem.Byte
sbyteSystem.SByte
charSystem.Char
decimalSystem.Decimal
doubleSystem.Double
floatSystem.Single
intSystem.Int32
uintSystem.UInt32
longSystem.Int64
ulongSystem.UInt64
objectSystem.Object
shortSystem.Int16
ushortSystem.UInt16
stringSystem.String
Все эти типы, за исключением object и string, являются типами значений. Дополнительные сведения см. в разделе Типы значений и ссылочные типы.
Использование встроенных типов данныхВстроенные типы данных используются в программах C# несколькими способами.
Как переменные.
int answer = 42;
string greeting = "Hello, World!";
Как константы.
const int speedLimit = 55;
const double pi = 3.14159265358979323846264338327950;
Как возвращаемые значения и параметры.
long CalculateSum(int a, int b)
{
long result = a + b;
return result;
}
Преобразование типов данныхПреобразование между типами данных можно сделать неявно, в этом случае преобразование автоматически выполняет компилятор, или явно с помощью приведения, в этом случае принудительное преобразование выполняет программист, учитывая риск возможной потери данных.
Пример.
int i = 0;
double d = 0;
i = 10;
d = i; // An implicit conversion
d = 3.5;
i = (int) d; // An explicit conversion, or "cast"
Приложение по встроенным типам
using System;
namespace nsBuilt_inTypes
{
class built_inTypesClass
{
///
/// Читает и возвращает переменную типа int с данным именем
///
/// имя переменной
///
static int ReadInt(string name)
{
int i;
string s = null;
Console.Write("Введите произвольное значение целого числа " + name + " ");
// Метод TryParse позволяет автоматически избегать ошибочного ввода
// Метод TryParse возвращает true или false в зависимости от того,
// можно ли перевести вводимую строку (первый параметр метода)
// в значение переменной вводимого типа.
// В случае удачного результата второй параметром метода возвращает введенное значение.
// Этот параметр снабжен модификатором out.
// При обращении к методу значение параметра с модификатором out
// не обязательно должно быть определено.
// Но метод обязан присвоить параметру с модификатором out какое-либо значение.
while (!int.TryParse(s = Console.ReadLine(), out i))
Console.WriteLine( "Введена строка " + s + ", которая не является значением переменной типа int!\n" +
"Значение должно лежать в интервале [{0};{1}].\n Повторите ввод ", int.MinValue, int.MaxValue);
return i;
}
///
/// Читает и возвращает переменную типа double с данным именем
///
/// имя переменной
///
static double ReadDouble(string name)
{
double d;
string s = null;
Console.Write("Введите произвольное значение числа с плавающей запятой " + name + " ");
while (!double.TryParse(s = Console.ReadLine(), out d))
Console.WriteLine( "Введена строка " + s + ", которая не является значением переменной типа double!\n" +
"Значение должно лежать в интервале [{0};{1}].\n Повторите ввод ", double.MinValue, double.MaxValue);
return d;
}
///
/// Формирует строку записи целого числа в данной системе счисления
///
/// целое число
/// основание системы счисления 2 или 16
///
///
static string IntToStr(int i, int @base)
{
switch (@base)
{
case 2: return Convert.ToString(i, 2).PadLeft(32, '0').Insert(24, " ").Insert(16, " ").
Insert(8, " ");
case 16: return
i.ToString("x").PadLeft(8, '0').Insert(6, " ").Insert(4, " ").Insert(2, " ");
default: return null;
}
}
///
/// Читает и возвращает переменную логического типа с данным именем
///
/// имя переменной
///
static bool ReadBoolean(string name)
{
bool b;
string s = null;
Console.Write("Введите значение логической переменной " +
name + " (true или false) ");
while (!bool.TryParse(s = Console.ReadLine(), out b))
Console.WriteLine( "Введена строка " + s + ", которая не является значением переменной типа bool!\n" +
"Значение должно быть true (True) или false (False).\n Повторите ввод ");
return b;
}
///
/// Анализирует встроенные типы и операции с ними
///
///
static void Main(string[] args)
{
Console.WriteLine("Наиболее популярные типы переменных C# это int, double, bool.\n");
// Описание переменной типа int
int i;// i является локальной переменной (действует только внутри метода main),
// которая хранит в дальнейшем значение переменной типа int
// Вначале значение i не опредлено.
// Попытка вывести значение i на экран приведет к ошибке
// "use of unassigned local variable" на стадии компиляции
// Console.WriteLine(i);
// Ввод с консоли значения переменной типа int
/*
Console.Write("Введите значение i ");
// Чтение переменной типа i с консоли
i = int.Parse( Console.ReadLine() // С консоли можно прочесть только строку!
);
// Строку можно превратить в значение переменной типа int методом Parse
// соответствующего типа.
// Другой класс Convert и его метод ToInt32 также позволяет превратить
// вводимую строку в значение целого типа int
// i = Convert.ToInt32(Console.ReadLine());
*/
// Описание переменной типа double
double d;
// Описание переменной типа string
String s;
string s1, s2;
// Описание переменной логического типа
Boolean b;
#region Целый тип
// Переменные типа Int32 (или int) занимают 4 байта
// и принимают целые значения в интервале [-2^31; 2^31 - 1]
Console.WriteLine("Переменные типа System.Int32 (или int) занимают {0} байта памяти.", sizeof(int));
Console.WriteLine("Максимальное значение переменной типа int:\n {0}",
// Форматирование выводимой строки длинного целого числа,
// которое позволяет разбить число на триады
int.MaxValue.ToString("n0"));
Console.WriteLine(" в бинарном формате: " + IntToStr(int.MaxValue, 2));
Console.WriteLine(" в шестнадцатеричном формате: " + IntToStr(int.MaxValue, 16));
Console.WriteLine("Мимнимальное значение переменной типа int:\n {0}", Int32.MinValue.ToString("n0"));
Console.WriteLine(" в бинарном формате: " + IntToStr(int.MinValue, 2));
Console.WriteLine(" в шестнадцатеричном формате: " + IntToStr(int.MinValue, 16) + "\n");
do {
i = ReadInt("i");
// Определяется тип переменной методами GetTypeCode или GetType
Console.WriteLine("Тип переменной i определяется методами TypeCode:{0} или Type:{1}", i.GetTypeCode(), i.GetType());
Console.WriteLine("Введено значение i = {0:n0};\n в бинарном формате: {1};\n" +
" в шестнадцатеричном формате: {2}", i, IntToStr(i, 2), IntToStr(i, 16));
// Операции над int
// Унарные
Console.WriteLine("\nОперации над числами типа int");
Console.WriteLine("Часто используемые операции над целыми числами\n");
// Унарный минус
Console.WriteLine("Оператор унарного минуса -i = {0};\n в бинарном формате: {1};\n" +
" в шестнадцатеричном формате: {2}", -i, IntToStr(-i, 2), IntToStr(-i, 16));
Console.WriteLine("Оператор i++ возвращает i, после чего увеливиает i на 1. Поэтому i++ = {0}", i++); Console.WriteLine("Новое значение i = {0}", i);
Console.WriteLine("Оператор ++i увеличивает i на 1, после чего возвращает новое значение i. Поэтому ++i = {0}", ++i);
Console.WriteLine("Новое значение i = {0}\n в бинарном формате: {1};\n" +
" в шестнадцатеричном формате: {2}", i, IntToStr(-i, 2), IntToStr(-i, 16));
Console.WriteLine("Нажмите esc для продолжения и любую клавишу для повтора.");
}
while (Console.ReadKey(true).Key != ConsoleKey.Escape);
// Часто используемые
// Сложение, вычитание, умножение, деление
Console.WriteLine("\nЧасто используемые бинарные операции над целыми числами");
int i1, i2;
Console.WriteLine("Введите значения двух целых переменных");
do {
i1 = ReadInt("i1");
i2 = ReadInt("i2");
Console.WriteLine("По умолчанию переполнение (выход за допустимый диапазон значений) у целых чисел не регистрируется."); Console.WriteLine("Необходимо применять оператор checked");
Console.WriteLine("Сумма {0} + " + (i2 < 0 ? "({1})" : "{1}") + " = {2}", i1, i2, checked(i1 + i2));
Console.WriteLine("Разность {0} - " + (i2 < 0 ? "({1})" : "{1}") + " = {2}", i1, i2, i1 - i2);
Console.WriteLine("Произведение {0} * " + (i2 < 0 ? "({1})" : "{1}") + " = {2}", i1, i2, i1 * i2);
Console.WriteLine("Обратить внимание на то, что результатом деления целых всегда является целое. Дробная часть отбрасывается."); try {
// Здесь checked не играет роли!
Console.WriteLine("Частное {0} / " + (i2 < 0 ? "({1})" : "{1}") + " = {2}", i1, i2, i1 / i2);
}
catch (DivideByZeroException e)
{
Console.WriteLine(e.Message);
}
Console.WriteLine("Остаток от деления нацело {0} % " + (i2 < 0 ? "({1})" : "{1}") + " = {2}", i1, i2, i1 % i2);
// Сравнение
Console.WriteLine("Операторы сравнения:\n равенство i1 == i2 {0}," + "\n неравенство i1 != i2 {1},\n" + " неравенство i1 > i2 {2},\n"
+ " неравенство i1 < i2 {3}\n" + " неравенство i1 >= i2 {4},\n"
+ " неравенство i1 <= i2 {5}", i1 == i2, i1 != i2, i1 > i2, i1 < i2, i1 >= i2, i1 <= i2);
Console.WriteLine("Нажмите esc для продолжения и любую клавишу для повтора.");
}
while (Console.ReadKey(true).Key != ConsoleKey.Escape);
// Редко используемые
Console.WriteLine("\nРедко используемые операции над целыми числами");
do {
i = ReadInt("i");
Console.WriteLine("Введено значение i = {0:n0};\n в бинарном формате: {1};\n" +
" в шестнадцатеричном формате: {2}", i, IntToStr(i, 2), IntToStr(i, 16));
// Инверсия битов
int invI = ~i;
Console.WriteLine("Оператор инверсии ~i = {0};\n в бинарном формате: {1};\n" +
" в шестнадцатеричном формате: {2}", invI, IntToStr(invI, 2), IntToStr(invI, 16));
Console.WriteLine("Сдвиги влево и вправо на n бит эквивалентны умножению на 2^n,");
Console.WriteLine("где n положительное при сдвиге влево и отрицательное при сдвиге вправо.");
int left3I = i << 3, right2I = i >> 2; ;
Console.WriteLine("Оператор сдвига влево на три бита i << 3 = {0};\n" +
" в бинарном формате: {1};\n в шестнадцатеричном формате: {2}", left3I, IntToStr(left3I, 2), IntToStr(left3I, 16));
Console.WriteLine("Оператор сдвига вправо на два бита i >> 2 = {0};\n" +
" в бинарном формате: {1};\n в шестнадцатеричном формате: {2}", right2I, IntToStr(right2I, 2), IntToStr(right2I, 16));
Console.WriteLine("Нажмите esc для продолжения и любую клавишу для повтора.");
}
while (Console.ReadKey(true).Key != ConsoleKey.Escape);
// Бинарные побитовые операции над переменными типа int
Console.WriteLine("\nРедко используемые бинарные операции над целыми числами");
Console.WriteLine("Введите значения двух целых переменных");
do {
i1 = ReadInt("i1");
i2 = ReadInt("i2");
Console.WriteLine("Значение i1 = {0};\n в бинарном формате: {1};\n" +
" в шестнадцатеричном формате: {2}", i1, IntToStr(i1, 2), IntToStr(i1, 16));
Console.WriteLine("Значение i2 = {0};\n в бинарном формате: {1};\n" +
" в шестнадцатеричном формате: {2}", i2, IntToStr(i2, 2), IntToStr(i2, 16));
Console.WriteLine("Оператор побитового сложения i1 | i2 = {0};\n" +
" в бинарном формате: {1};\n в шестнадцатеричном формате: {2}", i1 | i2, IntToStr(i1 | i2, 2), IntToStr(i1 | i2, 16));
Console.WriteLine("Оператор побитового умножения i1 & i2 = {0};\n" +
" в бинарном формате: {1};\n в шестнадцатеричном формате: {2}", i1 & i2, IntToStr(i1 & i2, 2), IntToStr(i1 & i2, 16));
Console.WriteLine("Оператор побитовой симметричной разности i1 ^ i2 = {0};\n" +
" в бинарном формате: {1};\n в шестнадцатеричном формате: {2}", i1 ^ i2, IntToStr(i1 ^ i2, 2), IntToStr(i1 ^ i2, 16));
// Методы ReferenceEquals и Equals - сравнение ссылок и значений
Console.WriteLine("\nОписываем два разных объекта i1 и i2 типа int. Присваиваем одинаковые значения i1 = 1; i2 = i1;.");
i1 = 1; i2 = i1;
Console.WriteLine("Методами int.ReferenceEquals и int.Equals проверяем, совпадают ли ссылки и значения.");
Console.WriteLine("int.ReferenceEquals(i1, i2) = {0} -> ссылки не совпадают\nint.Equals(i1, i2) = {1} -> Значения совпадают",
int.ReferenceEquals(i1, i2), int.Equals(i1, i2));
Console.WriteLine("Нажмите esc для продолжения и любую клавишу для повтора.");
}
while (Console.ReadKey(true).Key != ConsoleKey.Escape);
#endregion
#region double
// Переменные типа Double (или double) занимают 8 байт и принимают вещественные значения в интервале [~-10^308;~10^308]
Console.WriteLine("Переменные типа Double (или double) занимают {0} байт памяти.",
sizeof(double));
Console.WriteLine("Максимальное значение переменной типа double:\n {0}", double.MaxValue);
Console.WriteLine("Мимнимальное значение переменной типа double:\n {0}", Double.MinValue);
Console.WriteLine("Минимальное отличное от нуля число типа Double {0}", Double.Epsilon);
do {
d = ReadDouble("d");
// Определяется тип переменной методами GetTypeCode или GetType
Console.WriteLine("Тип переменной d определяется методами TypeCode:{0} или Type:{1}", d.GetTypeCode(), d.GetType());
Console.WriteLine("Введено значение d = {0};\n" +
" в формате f: {0:f}; в формате g: {0:g}; в формате e: {0:e};\n" +
" в формате f5: {0:f5}; в формате g1: {0:g1}; в формате E3: {0:E3}", d);
// Операции над double
// Сложение, вычитание, умножение, деление
Console.WriteLine("Операции над числами типа double");
double d1, d2;
Console.WriteLine("Введите значения двух переменных типа Double");
d1 = ReadDouble("d1");
d2 = ReadDouble("d2");
Console.WriteLine("Сумма {0} + " + (d2 < 0 ? "({1})" : "{1}") + " = {2}", d1, d2, d1 + d2);
Console.WriteLine("Разность {0} - " + (d2 < 0 ? "({1})" : "{1}") + " = {2}", d1, d2, d1 - d2);
Console.WriteLine("Произведение {0} * " + (d2 < 0 ? "({1})" : "{1}") + " = {2}", d1, d2, d1 * d2);
// Обратить внимание на то, что при делении переменных типа double,
// никогда не возникает исключительной ситуации.
Console.WriteLine("Частное {0} / " + (d2 < 0 ? "({1})" : "{1}") + " = {2}", d1, d2, d1 / d2);
Console.WriteLine("Остаток от деления нацело {0} % " + (d2 < 0 ? "({1})" : "{1}") + " = {2}", d1, d2, d1 % d2);
// Сравнение
Console.WriteLine("Операторы сравнения:\n равенство d1 == d2 {0}," + "\n неравенство d1 != d2 {1},\n" + " неравенство d1 > d2 {2},\n"
+ " неравенство d1 < d2 {3},\n" + " неравенство d1 >= d2 {4},\n"
+ " неравенство d1 <= d2 {5}", d1 == d2, d1 != d2, d1 > d2, d1 < d2, d1 >= d2, d1 <= d2);
// Методы ReferenceEquals и Equals - сравнение ссылок и значений
Console.WriteLine("\nОписываем два разных объекта d1 и d2 типа double. Присваиваем одинаковые значения d1 = 1.0e-9; d2 = d1;."); d1 = 1.0e-9; d2 = d1;
Console.WriteLine("Методами double.ReferenceEquals и double.Equals проверяем, совпадают ли ссылки и значения.");
Console.WriteLine("double.ReferenceEquals(d1, d2) = {0} -> ссылки не совпадают\ndouble.Equals(d1, d2) = {1} -> Значения совпадают",
double.ReferenceEquals(d1, d2), double.Equals(d1, d2));
Console.WriteLine("Нажмите esc для продолжения и любую клавишу для повтора.");
}
while (Console.ReadKey(true).Key != ConsoleKey.Escape);
#endregion
#region string
do {
Console.Write("Введите значение строки s ");
s = Console.ReadLine();
// Определяется тип переменной методами GetTypeCode или GetType
Console.WriteLine("Тип переменной s определяется методами TypeCode:{0} или Type:{1}", s.GetTypeCode(), s.GetType());
Console.WriteLine("Введено значение s = {0} длиной s.Length = {1}", s, s.Length);
// Операции над string
Console.WriteLine("Операции над переменными типа String");
string str1, str2;
Console.WriteLine("Введите значения двух переменных типа String");
Console.Write(" s1: "); str1 = Console.ReadLine();
Console.Write(" s2: "); str2 = Console.ReadLine();
Console.WriteLine("Сумма {0} + {1} = {2}", str1, str2, str1 + str2);
// Сравнение
Console.WriteLine("Операторы сравнения: равенство s1 == s2 {0} " +
"и неравенство s1 != s2 {1}", str1 == str2, str1 != str2);
Console.WriteLine("\nМетодами double.ReferenceEquals и double.Equals проверяем, совпадают ли ссылки и значения.");
Console.WriteLine("Неизменяемость (immutability) объектов типа string.");
s1 = "abc"; s2 = "abcd";
Console.WriteLine("Берем две разных строки s1 и s2. Вначале имеют разные значения s1 = {0}; s2 = {1}.", s1, s2); Console.WriteLine("string.ReferenceEquals(s1, s2) = {0} -> ссылки не совпадают\nstring.Equals(s1, s2) = {1} -> значения не совпадают",
string.ReferenceEquals(s1, s2), string.Equals(s1, s2));
s2 = "abc";
Console.WriteLine("Затем второй присваивается такое же значение, как у первой s2 = {0}", s2);
Console.WriteLine("string.ReferenceEquals(s1, s2) = {0} -> ссылки совпадают\nstring.Equals(s1, s2) = {1} -> значения совпадают",
string.ReferenceEquals(s1, s2), string.Equals(s1, s2));
Console.WriteLine("Нажмите esc для продолжения и любую клавишу для повтора.");
}
while (Console.ReadKey(true).Key != ConsoleKey.Escape);
#endregion
#region Логический тип
Console.WriteLine("\n Переменные типа bool (булевские, или логические) принимают два значения true (правда) и false (ложь).");
Console.WriteLine(" bool - псевдоним имени System.Boolean. Это имя стандартной структуры, являющейся частью библиотеки.NET."); // Переменные типа bool занимают 1 байт памяти
Console.WriteLine("Переменная типа Boolean (или bool) занимает {0} байт памяти.\n", sizeof(Boolean));
do {
b = ReadBoolean("b");
// Определяется тип переменной методами GetTypeCode или GetType
Console.WriteLine("Тип переменной b определяется методами TypeCode:{0} или Type:{1}",
b.GetTypeCode(), b.GetType());
Console.WriteLine("Введено значение b = {0}", b);
Console.WriteLine("Оператор отрицания !b = {0}", !b);
// Бинарные операции с логическими переменными
bool b1, b2;
Console.WriteLine("Введите значения двух логических переменных");
b1 = ReadBoolean("b1");
b2 = ReadBoolean("b2");
Console.WriteLine("Введены значения b1 = {0}; b2 = {1}", b1, b2);
Console.WriteLine("Оператор логического \"или\" b1 | b2 = {0}", b1 | b2);
Console.WriteLine("Оператор сокращенного вычисления логического \"или\" b1 || b2 = {0}",
b1 || b2);
Console.WriteLine("Оператор логического \"и\" b1 & b2 = {0}", b1 & b2);
Console.WriteLine("Оператор сокращенного вычисления логического \"и\" b1 && b2 = {0}",
b1 && b2);
Console.WriteLine("Оператор логического исключающего \"или\" b1 ^ b2 = {0}",
b1 ^ b2);
// Сравнение
Console.WriteLine( "Операторы сравнения: равенство b1 == b2 {0} и неравенство b1 != b2 {1}",
b1 == b2, b1 != b2);
Console.WriteLine("Таблица бинарных операций");
Console.WriteLine(" b1 | b2 |(или)|| | (и)&& |(разность)^|");
for (i = 0; i < 2; i++)
{
b1 = i == 0;
for (int j = 0; j < 2; j++)
{
b2 = j == 0;
Console.WriteLine("{0,-8}|{1,8}|{2,8}|{3,8}|{4,11}|",
b1, b2, b1 || b2, b1 && b2, b1 ^ b2);
}
}
Console.WriteLine("Нажмите esc для продолжения и любую клавишу для повтора.");
}
while (Console.ReadKey(true).Key != ConsoleKey.Escape);
#endregion
#region object
Console.WriteLine("Тип object. Описываем два разных объекта object o1 = new object(), o2 = new object(). Имеют значения по умолчанию."); object o1 = new object(), o2 = new object();
Console.WriteLine("object.ReferenceEquals(o1, o2) = {0} -> ссылки не совпадают\nobject.Equals(o1, o2) = {1} -> значения не совпадают",
object.ReferenceEquals(o1, o2), object.Equals(o1, o2));
Console.WriteLine("Второму объекту присваиваем первый o2 = o1;.");
o2 = o1;
Console.WriteLine("object.ReferenceEquals(o1, o2) = {0} -> ссылки совпадают в отличие от типов int, double",
object.ReferenceEquals(o1, o2));
Console.WriteLine("object.Equals(o1, o2) = {0} -> значения совпадают", object.Equals(o1, o2));
#endregion
#region Другие встроенные типы данных
Console.WriteLine("\nДругие встроенные типы");
// Перечисляются свойства встроенных типов
Console.WriteLine("Целочисленные типы:\n" + " System.Byte (или byte): sizeof(byte) = {0} байт\n" +
" MaxValue = {1} или {1:x2} или {2};\n MinValue = {3,3} или {3:x2} или {4}\n", sizeof(byte),
byte.MaxValue, Convert.ToString(byte.MaxValue, 2).PadLeft(8, '0'),
byte.MinValue, Convert.ToString(byte.MinValue, 2).PadLeft(8, '0'));
Console.WriteLine( " System.SByte (или sbyte): sizeof(sbyte) = {0} байт.\n" +
" MaxValue = {1,4} или {1:x2} или {2};\n MinValue = {3} или {3:x2} или {4}\n", sizeof(sbyte),
sbyte.MaxValue, Convert.ToString(sbyte.MaxValue, 2).PadLeft(8, '0'),
// Обратите внимание на преобразование типов и оператор unchecked
sbyte.MinValue, Convert.ToString(unchecked((byte)sbyte.MinValue), 2).PadLeft(8, '0'));
Console.WriteLine( " System.Int16 (или short): sizeof(short) = {0} байт.\n" +
" MaxValue = {1,7:n0} или {1:x4} или {2};\n MinValue = {3,7:n0} или {3:x4} или {4}\n", sizeof(short),
short.MaxValue, Convert.ToString(short.MaxValue, 2).PadLeft(16, '0'),
short.MinValue, Convert.ToString(short.MinValue, 2).PadLeft(16, '0'));
Console.WriteLine( " System.UInt16 (или ushort): sizeof(ushort) = {0} байт.\n" +
" MaxValue = {1:n0} или {1:x4} или {2};\n MinValue = {3,6:n0} или {3:x4} или {4}\n", sizeof(ushort),
ushort.MaxValue, Convert.ToString(ushort.MaxValue, 2).PadLeft(16, '0'),
ushort.MinValue, Convert.ToString(ushort.MinValue, 2).PadLeft(16, '0'));
Console.WriteLine( " System.UInt32 (или uint): sizeof(uint) = {0} байт.\n" +
" MaxValue = {1:n0} или {1:x8} или {2};\n MinValue = {3,13:n0} или {3:x8} или {4}\n", sizeof(uint),
uint.MaxValue, Convert.ToString(uint.MaxValue, 2).PadLeft(32, '0'),
uint.MinValue, Convert.ToString(uint.MinValue, 2).PadLeft(32, '0'));
Console.WriteLine( " System.Int64 (или long): sizeof(long) = {0} байт.\n" +
" MaxValue = {1,26:n0} или {1:x16} или {2};\n MinValue = {3,26:n0} или {3:x16} или {4}\n", sizeof(long),
long.MaxValue, Convert.ToString(long.MaxValue, 2).PadLeft(64, '0'),
long.MinValue, Convert.ToString(long.MinValue, 2).PadLeft(64, '0'));
Console.WriteLine( " System.UInt64 (или ulong): sizeof(ulong) = {0} байт.\n" +
" MaxValue = {1:n0} или {1:x16} или {2};\n MinValue = {3,26:n0} или {3:x16} или {4}\n", sizeof(ulong),
ulong.MaxValue, Convert.ToString(unchecked((long)ulong.MaxValue), 2).PadLeft(64, '0'),
ulong.MinValue, Convert.ToString(unchecked((long)ulong.MinValue), 2).PadLeft(64, '0'));
Console.WriteLine( " Символьный тип System.Char (или char): sizeof(char) = {0} байт.\n\n" +
" System.Decimal Десятичный тип для финансовых расчетов Decimal (или decimal): sizeof(decimal) = {1} байт.\n" +
" MaxValue = {2:n0};\n MinValue = {3:n0}\n", sizeof(char), sizeof(decimal), decimal.MaxValue, decimal.MinValue);
Console.WriteLine( " Тип с плавающей запятой:\n System.Single (или float): sizeof(float) = {0} байт.\n" +
" MaxValue = {1};\n MinValue = {2}\n", sizeof(float), float.MaxValue, float.MinValue);
#endregion
Console.WriteLine("Нажмите Enter для завершения программы.");
Console.ReadLine();
}
}
}
Приложение по циклам
static void Main()
{
Console.WriteLine("Циклы\nЦиклом называется один или несколько операторов, повторяющихся заданное число раз\n" +
"или до тех пор, пока не будет выполнено определенное условие.\n" +
"В языке C# существует 4 разновидности цикла:\n" +
"1. Цикл с перечислением (цикл типа for)\n2. Цикл с предусловием (типа while)\n" +
"3. Цикл с постусловием (типа do-while)\n4. Цикл итерации (типа foreach)\n\nЦикл с перечислением (типа for)\n" +
"Выполнение простого примера цикла for\nfor (int i = 0; i < 5; i++)\n Console.WriteLine(i);\nдает результат");
for (int i = 0; i < 5; i++)
Console.WriteLine(i);
Console.WriteLine("Каждый цикл for(init;condition;iterator) в круглых скобках определяет три раздела:\n" +
"раздел инициализации (init), условие завершения цикла (condition) и раздел итератора (iterator).\n" +
"В приведенном примере:\n" +
"раздел инициализации описывает локальную переменную i, придавая ей начальное значение 0;\n" +
"условие i < 5, при выполнении которого цикл выполняется\n" +
"раздел итерации, изменяет значение переменной i, увеливая ее на единицу оператором ++.\n" +
"1. Раздел инициализации выполняется в самом начале и только один раз.\n" +
"2. Вслед за разделом инициализации выполняется раздел проверки условия завершения цикла.\n" +
" Далее следует ветвление выполнения программы:\n" +
" либо, если условие выполняется,\n" +
" то выполняется оператор, стоящий в цикле (в примере - вывод на экран числа i).\n" +
" либо,если условие не выполняется,\n" +
" то управление передается оператору, следующему за циклом (завершение цикла).\n" +
"3. После выполнения оператора, стоящего в цикле, выполняется раздел итерации.\n" +
"После итерации вновь, как и после инициализации, выполняется выполняется раздел 2 выполнения условия.\n" +
"За ним ветвление и т.д. до завершения цикла.\n" +
"Разделы инициализации и итерации (но не условие) могут состоять из нескольких операторов, разделенных запятыми.\n" +
"К примеру код\nint j;\nfor (j = 0, Console.WriteLine(j); j < 5; j++, Console.WriteLine(j))\n" +
"// Оператор внутри цикла отсутствует\n;\nдает почти тот же результат, что и предыдущий (объясните причину отличия).");
int j;
for (j = 0, Console.WriteLine(j); j < 5; j++, Console.WriteLine(j))
// Оператор внутри цикла отсутствует
;
Console.WriteLine("\nЦикл с предусловием while имеет более примитивную структуру while(condition).\n" +
"В его описании есть только раздел условия, при выполнении которого операторы в теле цикла выполняются.\n" +
"Тот же код, что записан выше, будет выглядеть следующим образом:\n" +
"int l=0;\nwhile(l<5)\n{\n Console.WriteLine(\"l = {0}\",l);\n l++;\n}\nПосмотрите результат");
int l = 0;
while (l < 5)
{
Console.WriteLine("l = {0}", l);
l++;
}
Console.WriteLine( "Как видим, для алгоритма перечисления с изменением параметра больше подходит цикл типа for,\n" +
"который естественным образом включает в свою запись разделы инициализации и итерации.\n" +
"Цикл типа while имеет смысл применять в алгоритмах, не содержащих перечисления.\n" +
"Например, если необходимо проверить правильность ввода числа с клавиатуры,\n" +
"можно использовать метод TryParse в следующих операторах с циклом while\n" +
"int n;\nConsole.Write(\"Введите целое число n = \");\nwhile(!int.TryParse(Console.ReadLine(),out n))\n" +
" Console.Write(\"Ошибка ввода. Попробуйте еще раз.\\nn = \");\nConsole.WriteLine(\"OK!\");");
int n;
Console.Write("Введите целое число n = ");
while (!int.TryParse(Console.ReadLine(), out n))
Console.Write("Ошибка ввода. Попробуйте еще раз\nn = "); Console.WriteLine("OK!");
Console.WriteLine( "\nДругой пример использования цикла while.\n" +
"Найдем минимальную величину delta, которая меняет единицу.\n" +
"double delta = 1;\nwhile(1 != 1 + delta)\n delta *=.5;\n" +
"Console.WriteLine(\"delta = {0}\", 2 * delta);");
double delta = 1;
while (1 != 1 + delta)
delta *=.5;
Console.WriteLine("delta = {0}\nНажмите enter для продолжения.", 2 * delta);
Console.ReadLine();
Console.WriteLine("\nЦикл с постусловием do-while имеет структуру do {} while(condition).\n" +
"Раздел условия помещен в завершающую часть цикла,\n" +
"а операторы, из которых состоит тело цикла, расположены между do и while.\n" +
"Важное отличие цикла do-while от уже рассмотренных типов в том,\n" +
"что операторы тела цикла выполняются хотя бы один раз в самом начале.\n" +
"Пример алгоритма, в котором использование цикла do-while было бы к месту.\ndo\n{\n" + " Console.WriteLine(\"Здесь находится код, который должен выполниться хотя бы раз. Например, тело метода Main.\");\n" + " Console.WriteLine(\"Нажмите esc для завершения или любую клавишу для повтора.\");\n}\n" + "// Метод Console.Readkey возвращает структуру, описывающую нажатую на клавиатуре клавишу.\n" +
"// Параметр true требует, чтобы символ клавиши не выводился на экран.\n" +
"// Свойство Key структуры содержит значения перечислимого типа ConsoleKey.\n" +
"// Если нажатая клавиша не является esc, то условие возвращает true и оператор в теле цикла вновь выполнится.\n" +
"while (Console.ReadKey(true).Key != ConsoleKey.Escape);" +
"\nПосмотрите результат.");
do {
Console.WriteLine("Здесь находится код, который должен выполниться хотя бы раз. Например, тело метода Main."); Console.WriteLine("Нажмите esc для завершения или любую клавишу для повтора.");
}
while (Console.ReadKey(true).Key != ConsoleKey.Escape);
Console.WriteLine( "Большой пример использования циклов while и do-while.\n" +
"Найдем факториал заданного целого значения числа m.\n" +
"int m;\ndo\n{" + " Console.Write(\"Введите целое число m > 1 \");\n" +
" while(!int.TryParse(Console.ReadLine(), out m) || m < 2)// Обратите внимание на условие\n" +
" Console.Write(\"Ошибка ввода или m < 2. Попробуйте еще раз.\\nm = \");\n" + " int mCur = m;// Текущее значение m\n" +
" double f = 1;// Для подсчета факториала\n" +
" do\n f *= mCur--;\n" +
" while (mCur > 1);\n" +
" Console.WriteLine(\"{0}! = {1:n0}\", m, f);// Обратите внимание на строку формата n0\n" +
" Console.WriteLine(\"Нажмите esc для завершения или любую клавишу для повтора.\");\n}\n" + "while (Console.ReadKey(true).Key != ConsoleKey.Escape);\nПосмотрите работу кода");
int m;
do {
Console.Write("Введите целое число m > 1 ");
while (!int.TryParse(Console.ReadLine(), out m) || m < 2)// Обратите внимание на условие
Console.Write("Ошибка ввода или m < 2. Попробуйте еще раз.\nm = "); int mCur = m;// Текущее значение m
double f = 1;// для подсчета факториала
do f *= mCur--;
while (mCur > 1);
Console.WriteLine("{0}! = {1:n0}", m, f);// Обратите внимание на строку формата n0
Console.WriteLine("Нажмите esc для завершения или любую клавишу для повтора.");
}
while (Console.ReadKey(true).Key != ConsoleKey.Escape);
Console.WriteLine("\nЦикл foreach");
Console.WriteLine("Опишем небольшой массив чисел типа int и поместим в него нечетные числа.\n" +
"Так выглядит описание и инициализация массива\nint[] odd = { 1, 3, 5, 7, 9, 11 };\n" +
"Используем цикл foreach для вывода этих чисел на экран\nforeach (int oddNmb in odd)\n" +
" Console.WriteLine(oddNmb);");
int[] odd = { 1, 3, 5, 7, 9, 11 };
Console.WriteLine("Немного нечетных чисел");
foreach (int oddNmb in odd)
Console.WriteLine(oddNmb);
Console.WriteLine("Нажмите enter для продолжения.");
Console.ReadLine();
Console.WriteLine("Другой пример\n" +
"Выше у нас был пример так называемого перечислимого типа (enumerable, сокращенно enum).\n" +
"Это был тип ConsoleKey, в котором перечислялись все клавиши клавиатуры.\n" +
"Рассмотрим еще один перечислимый тип ConsoleColor.\n" +
"Набрав имя ConsoleColor и поставив точку, мы получим список цветов,\n" +
"которые могут быть отображены в \"черном окне\" консоли.\n" +
"Используя цикл foreach, можно перечислить все цвета изображения текста\n" +
"foreach (ConsoleColor clr in Enum.GetValues(typeof(ConsoleColor)))\n" +
"{\n" +
" Console.ForegroundColor = clr;\n" +
" Console.WriteLine(clr);\n" +
"}\n");
foreach (ConsoleColor clr in Enum.GetValues(typeof(ConsoleColor)))
{
Console.ForegroundColor = clr;
Console.WriteLine(clr);
}
Console.WriteLine("Нажмите enter для продолжения.");
Console.ReadLine();
Console.WriteLine("Здесь использовался метод GetValues класса Enum,\n" +
"который возвращает массив всех значений указанного перечислимого типа (в данном случае ConsoleColor). \n" +
"Аргументом метода GetValues является объект класса Type.\n" +
"Объекты класса Type отражают информацию об объектах любого класса.\n" +
"Это так называемая мета-информация. Получить объект класса Type," +
"отвечающий любому классу, можно, воспользовавшись оператором typeof.");
Console.WriteLine("Нажмите enter для продолжения.");
Console.ReadLine();
Console.WriteLine("Еще один пример\n" +
"Используем цикл foreach для вывода на экран дней недели.\n" +
"Это элементы перечислимого типа DayOfWeek.\n" +
"foreach (DayOfWeek day in Enum.GetValues(typeof(DayOfWeek)))\n" +
"{\n" + " // Если хотим вывести только рабочие дни\n" +
" if (day == DayOfWeek.Saturday || day == DayOfWeek.Sunday)\n" +
" continue;\n" +
" Console.WriteLine(day);\n" +
"}");
Console.WriteLine("Рабочие дни недели");
foreach (DayOfWeek day in Enum.GetValues(typeof(DayOfWeek)))
{
// Если хотим вывести только рабочие дни
if (day == DayOfWeek.Saturday || day == DayOfWeek.Sunday)
continue;
Console.WriteLine(day);
}
}
«