INFO.Z-PDF.RU
БИБЛИОТЕКА  БЕСПЛАТНЫХ  МАТЕРИАЛОВ - Интернет документы
 

«Современная версия 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

/// строка, представляющая число

/// base является служебным слово языка. Чтобы использовать как идентификатор, надо добавить @

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);

}

}

Похожие работы:

«Смоленские ученые открыли еще одну неизвестную страницу литературной жизни России второй половины XIX века. Спустя столетие из небытия к нам вернулся поэт и философ Герв...»

«ИДЕЙНОЕ СОДЕРЖАНИЕ И ЯЗЫКОВЫЕ ОСОБЕННОСТИ РАССКАЗАМ. ШОЛОХОВА "СУДЬБА ЧЕЛОВЕКА"NI DUNG T TNG V C IM VN PHONG NGN NG CA TRUYN NGN “S PHN CON NGI” (M. SHOLOKHOV) Выполнитель: Нгуен Нгок Зиеп Чи Доктор филологических наук Ле Дык ТхуОГЛАВЛЕНИЕ TOC \o 1-3 \h \z \u ВВЕДЕНИЕ PAGEREF _Toc389647590 \h 11.Актуальность выбра...»

«Тема урока: Фольклор в музыке русских композиторов. Симфоническая картина А.К. Лядова "Кикимора". Цель: Формирование представлений обучающихся об интонационной природе музыки, о её изобразительных и выразительных возможностей, создающих в воображении ребёнка музыкальный образ.Задачи:Образовательные: Позн...»

«СРЕДНЕСРОЧНОЕ ПЛАНИРОВАНИЕ ОБЩАЯ ТЕМА СЕРИИ УРОКОВ: English-speaking countriesКонтекст:Цель обучения по предмету:Учащиеся будут знать:новый лексический материалбудут уметь работать с текстом, обрабатывать, выделять ключевые идеи, анализировать, выявлять сходства и различия, пользоваться ИКТ Пр...»

«МИНОБРНАУКИ _ Федеральное государственное бюджетное образовательное учреждение высшего профессионального образования <Назавание> Кафедра <> Бакалавр кафедры (название кафедры) (Фамилия И.О.) Специальность 00.00.АССИМИЛЯТОРНЫЕ ПРОЦ...»

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

«Календарно-тематическое планирование по английскому языку в 11 "Б" классе в 2015-2016 учебном году. Раздел Тема урока Кол-во часов Дата Лексика Грамматика АудированиеЧтение Говорение Письмо Основные вид...»

«План-конспект урока английского языка в 4 классе УМК: "Enjoy English-4", авторы: Биболетова М.З.; Денисенко О. А., Трубанева Н. Н., Тема: “SEASONS and WEATHER” Цель: повторение и обобщение лексико-грамматического материала по теме "Погода...»








 
2018-2023 info.z-pdf.ru - Библиотека бесплатных материалов
Поддержка General Software

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 2-3 рабочих дней удалим его.