}
Элемент инициализация обычно представляет собой инструкцию присваивания, которая устанавливает управляющую переменную цикла равной начальному значению.
С# включает специальный оператор инкремента, который позволяет более эффективно выполнить операцию увеличения значения на единицу. Оператор инкремента обозначается двумя последовательными знаками "плюс" (++)
count = count + 1; идентично count++;
for(count = 0; count < 5; count++)
В С# предусмотрен оператор декремента (--), который уменьшает значение операнда на единицу.
Цикл while
Общая форма цикла while имеет такой вид:
whi1е (условие) инструкция;
Здесь под элементом инструкция понимается либо одиночная инструкция, либо блок инструкций. Работой цикла управляет элемент условие, который представляет собой любое допустимое выражение типа bool. Элемент инструкция выполняется до тех пор, пока условное выражение возвращает значение ИСТИНА. Как только это условие становится ложным, управление передается инструкции, которая следует за этим циклом.
// Вычисление порядка целого числа.
using System;
class WhileDemo {
public static void Main() {
int num;
int mag;
num = 435679;
mag = 0;
Console.WriteLine("Число: " + num);
while (num > 0) {
mag++;
num = num /10;
};
Console.WriteLine("Порядок: " + mag);
}
}
Результаты выполнения этой программы:
Число: 435679
Порядок: 6
Цикл do - while
В отличие от циклов for и while, в которых условие проверяется при входе, цикл do-while проверяет условие при выходе из цикла. Это значит, что цикл do-while всегда выполняется хотя бы один раз.
Его общий формат имеет такой вид:
do {
инструкции;
} while {условие);
Цикл do-while выполняется до тех пор, пока остается истинным элемент условие, который представляет собой условное выражение.
// Отображение в обратном порядке цифр целого числа.
using System;
class DoWhileDemo {
public static void Main() {
int num;
int nextdigit;
num = 198;
Console.WriteLine("Число: " + num);
Console.Write("Число с обратным порядком цифр: ");
do {
nextdigit = num % 10;
Console.Write(nextdigit);
um = num / 10;
} while(num > 0);
Console.WriteLine();
}
}
Результат выполнения этой программы выглядит так:
Число: 198
Число с обратным порядком цифр: 891
На каждой итерации крайняя справа цифра определяется как остаток от целочисленного деления заданного числа на 10. Полученная цифра тут же отображается на экране. Затем результат этого деления запоминается в той же переменной num. Поскольку деление целочисленное, его результат равносилен отбрасыванию крайней правой цифры. Этот процесс повторяется до тех пор, пока число num не станет равным нулю.
Инструкция goto
Инструкция goto — это С#-инструкция безусловного перехода. При ее выполнении управление программой передается инструкции, указанной с помощью метки.
Метка — это действительный в С# идентификатор, за которым поставлено двоеточие. Метка должна находиться в одном методе с инструкцией goto, которая ссылается на эту метку. Например, с помощью goto можно организовать следующий цикл на 100 итераций:
х = 1;
loopl:
x++;
if(x < 100) goto loopl;
Инструкцию goto можно также использовать для перехода к case- или default-ветви внутри инструкции switch.
Арифметические оператор
Арифметические операторы
| Оператор | Действие |
| + | Сложение |
| - | Вычитание, унарный минус |
| * | Умножение |
| / | Деление |
| % | Деление по модулю |
| -- | Декремент |
| ++ | Инкремент |
После применения оператора деления (/) к целому числу остаток будет отброшен. Например, результат целочисленного деления 10/3 будет равен 3. Остаток от деления можно получить с помощью оператора деления по модулю (%). Этот оператор возвращает остаток от деления нацело. Например, 10 % 3 равно 1. В С# оператор % можно применить как к целочисленным типам, так и типам с плавающей точкой. Например, 10,0 % 3,0 также равно 1.
Инкремент и декремент
Операторы инкремента (++) и декремента (--) увеличивают и уменьшают значение операнда на единицу, соответственно.
х = х + 1; аналогична такой постфиксной форме: х ++; в виде префиксной формы ++ х;
х = х - 1; аналогична такой постфиксной форме: х --; в виде префиксной формы -- х;
Если такой оператор применен в префиксной форме, то С# сначала выполнит эту операцию, чтобы операнд получил новое значение, которое затем будет использовано остальной частью выражения. Если же оператор применен в постфиксной форме, то С# использует в выражении его старое значение, а затем выполнит операцию, в результате которой операнд обретет новое значение.
Рассмотрим фрагмент кода:
х = 10;
y = ++х;
В этом случае переменная у будет установлена равной 11. Но если в этом коде префиксную форму записи заменить постфиксной, переменная у будет установлена равной 10:
х = 10;
у = х++;
В обоих случаях переменная х получит значение 11. Разница состоит лишь в том, в какой момент она станет равной 11 (до присвоения ее значения переменной у или после).
Инструкция у = х + х++; сначала суммирует значения х и х, после чего присваивает результат переменной у. Только затем она инкрементирует переменную х. Но инструкция у = х + ++х; с начала получает (и запоминает) исходное значение переменной х, затем инкрементирует его, суммирует новое значение с исходным, а результат суммирования присваивает переменной у.
Нетрудно заметить, что простая замена элемента х++ элементом ++х меняет числовой ряд, генерируемый программой, с четного на нечетный.
В выражении: х + ++х; значение переменной х суммируется с инкрементированным значением той же переменной х.
Операторы отношений и логические операторы
Операторы отношений оценивают по "двубальной системе" (ИСТИНА/ЛОЖЬ) отношения между двумя значениями, а логические определяют различные способы сочетания истинных и ложных значений.
| Операторы отношений | Логические операторы | ||
| Оператор | Значение | Оператор | Значение |
| == | Равно | & | И |
| != | Не равно | | | ИЛИ |
| > | Больше | ^ | Исключающее ИЛИ |
| < | Меньше | && | Сокращенное И |
| >= | Больше или равно | || | Сокращенное ИЛИ |
| <= | Меньше или равно | ! | НЕ |
Результат выполнения операторов отношений и логических операторов имеет тип bool.
Импликация — это логическая операция, результат которой будет ложным только в случае, когда левый операнд имеет значение ИСТИНА, а правый — ЛОЖЬ. (Операция импликации отражает идею о том, что истина не может подразумевать ложь.) Операцию импликации можно создать, используя комбинацию операторов! и |.
Таблица истинности основных логических операций
| X | Y | X&Y | X|Y | X^Y | !X | !X|Y |
| false | false | false | false | false | true | true |
| true | false | false | true | true | false | false |
| false | true | false | true | true | true | true |
| true | true | true | true | false | false | true |
Оператор присваивания
переменная = выражение;
Здесь тип элемента переменная должен быть совместим с типом элемента выражение.
Рассмотрим, например, следующий фрагмент кода.
int х, у, z;
х = у = z = 100; // Устанавливаем переменные х, у и z равными 100.
Составные операторы присваивания
Составные версии операторов присваивания существуют для всех бинарных операторов (т.е. для всех операторов, которые работают с двумя операндами). Общая форма их записи такова:
переменная ор = выражение;
Здесь элемент ор означает конкретный арифметический или логический оператор, объединяемый с оператором присваивания.
Возможны следующие варианты объединения операторов.
+= -= *= /=
%= &= |= ^=
Поскольку составные операторы присваивания выглядят короче своих несоставных эквивалентов, то составные версии часто называют укороченными операторами присваивания.
Составные операторы присваивания обладают двумя заметными достоинствами.
х = х + 10;
Используя составной оператор присваивания, ее можно переписать в таком виде: х += 10;
Пара операторов += служит указанием компилятору присвоить переменной х сумму текущего значения переменной х и числа 10.
А вот еще один пример. Инструкция
х = х - 100; аналогична такой: х -= 100;
Поразрядные операторы
В С# предусмотрен набор поразрядных операторов, которые расширяют области приложения языка С#. Поразрядные операторы действуют непосредственно на разряды своих операндов. Они определены только для целочисленных операндов и не могут быть использованы для операндов типа bool, float или double. Работают на побитовой основе.
| Оператор | Значение |
| & | Поразрядное И |
| | | Поразрядное ИЛИ |
| ^ | Поразрядное исключающее ИЛИ |
| >> | Сдвиг вправо |
| << | Сдвиг влево |
| ~ | Дополнение до 1 (унарный оператор НЕ) |
Операторы сдвига
В С# можно сдвигать значение влево или вправо на заданное число разрядов. Для это в С# определены следующие операторы поразрядного сдвига:
<< − сдвиг влево;
>> − сдвиг вправо.
Общий формат записи этих операторов такой:
значение << число битов;
значение >> число_битов.
Здесь значение — это объект операции сдвига, а элемент число_битов указывает, на сколько разрядов должно быть сдвинуто значение.
При сдвиге влево на один разряд все биты, составляющее значение, сдвигаются влево на одну позицию, а в младший разряд записывается нуль. При сдвиге вправо все биты сдвигаются, соответственно, вправо. Если сдвигу вправо подвергается значение без знака, в старший разряд записывается нуль. Если же сдвигу вправо подвергается значение со знаком, значение знакового разряда сохраняется. Если сдвигаемое значение отрицательно, при каждом сдвиге вправо в старший разряд записывается единица, а если положительно — нуль. При сдвиге как вправо, так и влево крайние биты теряются.
Оператор?
Оператор? используется для замены определенных типов конструкций if then-else и называется тернарным, поскольку он работает с тремя операторами. Его общий формат записи имеет такой вид:
Выражение 1? Выражение2: Выражение3;
Здесь Выражение1 должно иметь тип bool. Типы элементов Выражение2 и Выражение 3 должны быть одинаковы. Значение?-выражения определяется следующим образом. Вычисляется Выражение 1. Если оно оказывается истинным, вычисляется Выражение2, и результат его вычисления становится значением всего?-выражения. Если результат вычисления элемента Выражение1 оказывается ложным, значением всего?-выражения становится результат вычисления элемента ВыражениеЗ.
Пример, в котором переменной absval присваивается абсолютное значение переменной val.
absval = val < 0? -val: val; // Получаем абсолютное значение val.
Одномерные массивы
Массив (array) — это коллекция переменных одинакового типа, обращение к которым происходит с использованием общего для всех имени. В С# массивы могут быть одномерными или многомерными, хотя в основном используются одномерные массивы.
Одномерный массив — это список связанных переменных.
Для объявления одномерного массива используется следующая форма записи.
тип[] имя__массива = new тип [размер];
Здесь с помощью элемента записи тип объявляется базовый тип массива. Базовый тип определяет тип данных каждого элемента, составляющего массив. Обратите внимание на одну пару квадратных скобок за элементом записи ТИП. ЭТО означает, что определяется одномерный массив. Количество элементов, которые будут храниться в массиве, определяется элементом записи размер.
Рассмотрим пример. При выполнении приведенной ниже инструкции создается int-массив (состоящий из 10 элементов), который связывается со ссылочной переменной массива sample.
int [ ] sample = new int [10]; // sample содержит ссылку на область памяти, выделенную оператором new.
Доступ к отдельному элементу массива осуществляется посредством индекса. Индекс описывает позицию элемента внутри массива. В С# первый элемент массива имеет нулевой индекс. Поскольку массив sample содержит 10 элементов, его индексы изменяются от 0 до 9. Чтобы получить доступ к элементу массива по индексу, достаточно указать нужный номер элемента в квадратных скобках. Так, первым элементом
массива sample является sample [0], а последним — sample [9].
// Демонстрация использования одномерного массива.
using System;
class ArrayDemo {
public static void Main() {
int[ ] sample = new int[10];
int i;
for(i = 0; i < 10; i = i+1)
sample[i] = i;
for(i = 0; i < 10; i = i+1)
Console.WriteLine("sample[" + i + " ]: " + sample[i]);
}
}
Результаты выполнения этой программы имеют такой вид:
sample[0]: 0
sample[1]: 1
sample[2]: 2
sample[3]: 3
sample[4]: 4
sample[5]: 5
sample[6]: б
sample[7]: 7
sample[8]: 8
sample[9]: 9
Инициализация массива
Массивы можно инициализировать в момент их создания. Формат инициализации одномерного массива имеет следующий вид:
тип[] имя_массива = [vail, val2,..., valN];
Здесь начальные значения, присваиваемые элементам массива, задаются с помощью последовательности vail—vaIN. Значения присваиваются слева направо, в порядке возрастания индекса элементов массива. С# автоматически выделяет для массива область памяти достаточно большого размера, чтобы хранить заданные значения инициализации (инициализаторы). В этом случае нет необходимости использовать в явном виде оператор new.
// Вычисление среднего арифметического от множества значений.
using System;
class Average {
public static void Main() {
int[ ] nums = { 99, 10, 100, 18, 78, 23, 63, 9, 87, 49 };
int avg = 0;;
for(int i=0; i < 10; i++)
avg = avg + nums[i];
avg = avg / 10;
Console.WriteLine("Среднее: " + avg);
}
}
Массив можно инициализировать и такими способами:
1) int [ ] nums = new int [ ] { 99, 10, 100, 18, 78, 23, I 63, 9, 87, 49 };
2) int [ ] nums;
nums = new int [ ] { 99, 10, 100, 18, 78, 23, 63, 9, 87, 49 };
3) int [ ] nums = new int [10] { 99, 10, 100, 18, 78, 23, 63, 9, 87, 49 }; // размер массива nums явно задан равным 10.
Двумерные массивы
В двумерном массиве позиция любого элемента определяется двумя индексами. Если представить двумерный массив в виде таблицы данных, то один индекс означает строку, а второй — столбец.
Чтобы объявить двумерный массив целочисленных значений размером 10x20 с именем table, достаточно записать следующее:
Int [, ] table = new int [10, 20];
Для реального выделения памяти для массива с помощью оператора new используется конкретный синтаксис:
int [10, 20]
Чтобы присвоить число 10 элементу массива table, позиция которого определяется координатами 3 и 5, можно использовать следующую инструкцию:
table [ 3, 5] = 10;
Пример программы, которая заполняет двумерный массив числами от 1 до 12, а затем отображает содержимое этого массива.
using System;
class TwoD {
public static void MainO {
int t, i;
int[, ] table = new int[3, 4];
for(t=0; t < 3; ++t) {
for(i=0; i < 4; ++i) {
table[t,i] = (t*4)+i+l;
Console.Write(table[t,i] + " ");
}
Console.WriteLine();
}
}
}
В этом примере элемент массива table [0, 0] получит число 1, элемент table [0, 1] — число 2, элемент table [0, 2] — число 3 и т.д. Значение элемента table [2,3] будет равно 12.
Массивы трех и более измерений
В С# можно определять массивы трех и более измерений. Вот как объявляется многомерный массив:
тип [,.., ] имя = new тип[размер1,..., размерN];
Например, с помощью следующего объявления создается трехмерный целочисленный массив размером 4x10x3:
int [,,] multidim = new int [ 4, 10, 3];
Чтобы присвоить число 100 элементу массива multidim, занимающему позицию с координатами 2,4,1, используйте такую инструкцию:
multidim[2, 4, 1] = 100;
Рассмотрим программу, в которой используется трехмерный массив, содержащий ЗхЗхЗ-матрицу значений.
// Программа суммирует значения, расположенные на диагонали ЗхЗхЗ-матрицы.
using System;
class ThreeDMatrix {
public static void Main() {
int[,, ] m = new int [3, 3, 3];
int sum = 0;
int n = 1;
for (int x=0; x < 3; x++)
for(int y=0; у < 3; y++)
for (int z=0; z < 3; z++)
m[x, y, z] = n++;
sum = m[ 0, 0, 0] + m [ l, l, l ] + m[ 2, 2, 2 ];
Console.WriteLine("Сумма первой диагонали: " + sum);
}
}
Вот результаты выполнения этой программы:
Сумма первой диагонали: 42
Инициализация многомерных массивов
Многомерный массив можно инициализировать, заключив список инициализаторов каждой размерности в собственный набор фигурных скобок. Например для двумерного массива:
тип[,] имя_массива = {
{val, val, val,..., val}
{val, valf val,..., val}
……………………..
{val, val, val,..., val}
};
Здесь элемент val — значение инициализации. Каждый внутренний блок означает строку. В каждой строке первое значение будет сохранено в первой позиции массива, второе значение — во второй и т.д. Блоки инициализаторов отделяются запятыми, а точка с запятой становится только после закрывающей фигурной скобки.
Например, следующая программа инициализирует массив sqrs числами от 1 до 10 и квадратами этих чисел.
using System;
class Squares {
public static void Main() {
int[, ]sqrs = {
{ 1, 1 },
{ 2, 4 },
{ 3, 9 },
{ 4, 16 },
{ 5, 25 },
{ 6, 36 },
{ 7, 49 },
{ 8, 64 },
{ 9, 81 },
{ 10, 100 }
}
int i, j;
for(i=0; i < 10; i++) {
for(j=0; j < 2; j++)
Console.Write(sqrs[i,j] + " ");
Console.WriteLine();
}
}
}
Результаты выполнения этой программы:
1 1
2 4
3 9
4 16
5 25
6 36
7 49
8 64
9 81
10 100
Использование свойства Length
C каждым массивом связано свойство Length, содержащее количество элементов, которое может хранить массив.
// Использование свойства Length.
using System;
class LengthDemo {
public static void Main() {
int [ ] nums = new int [10];
Console.WriteLine("Длина массива nums равна " + nums.Length);
// Используем Length для инициализации массива nums.
for(int i=0; i < nums.Length; i++)
nums [i] = i * i;
// Теперь используем Length для отображения nums.
Console.Write("Содержимое массива nums: ");
for (int i=0; i < nums.Length; i++)
Console.Write(nums [i] + " ");
Console.WriteLine();
}
}
При выполнении этой программы получаются следующие результаты:
Длина массива nums равна 10
Содержимое массива nums: 0 1 4 9 16 25 36 49 64 81
Строки
Одним из самых важных типов данных С# является тип string. Он предназначен для определения и поддержки символьных строк. В С# строки являются объектами. При создании строкового литерала в действительности создается объект класса string. Например, в инструкции:
Console.WriteLine("В С# строки являются объектами.");
строка "В С# строки являются объектами." средствами языка С# автоматически превращена в объект класса string.
Создание строк
Самый простой способ создать объект типа string — использовать строковый литерал. Например, после выполнения приведенной ниже инструкции str будет объявлена ссылочной переменной типа string, которой присваивается ссылка на строковый литерал.
string str = "С#-строки - это мощная сила.";
В данном случае переменная str инициализируется последовательностью символов "С#-строки - это мощная сила.".
Можно также создать string-объект из массива типа char. Вот пример:
char[ ] charray = {‘ t’, ‘e’, ‘s’, t’};
string str = new string(charray);
После создания string-объект можно использовать везде, где разрешается использование строки символов, заключенной в кавычки. Например, string-объект можно использовать в качестве аргумента функции WriteLine ().
Работа со строками
Класс string содержит ряд методов, которые предназначены для обработки строк. Тип string также включает свойство Length, которое содержит длину строки.
Чтобы получить значение отдельного символа строки, достаточно использовать индекс. Например:
string str = " test ";
Console.WriteLine(string[0]);
При выполнении этого фрагмента программы на экран будет выведен символ t (первый символ слова "test"). Как и у массивов, индексация строк начинается с нуля. C помощью индекса нельзя присвоить символу внутри строки новое значение. Индекс можно использовать только для получения символа.
Наиболее часто используемые методы обработки строк
| static string Copy (string str) | Возвращает копию строки str |
| int compareTo (string str) | Возвращает отрицательное значение, если вызывающая строка меньше строки str, положительное значение, если вызывающая строка больше строки str, и нуль, если сравниваемые строки равны |
| int indexOf (string str) | Выполняет в вызывающей строке поиск подстроки, заданной параметром str. Возвращает индекс первого вхождения искомой подстроки или - 1, если она не будет обнаружена |
| int LastindexOf (string str) | Выполняет в вызывающей строке поиск подстроки, заданной параметром str. Возвращает индекс последнего вхождения искомой подстроки или - 1, если она не будет обнаружена |
| string ToLower () | Возвращает строчную версию вызывающей строки |
| string ToupperO | Возвращает прописную версию вызывающей строки |
С помощью оператора "+" можно конкатенировать (объединить) несколько строк.
Например, при выполнении этого фрагмента кода
string strl = "Один";
string str2 = "Два";
string str3 = "Три";
string str4 = strl + str2 + str3;
переменная str4 инициализируется строкой "ОдинДваТри". Ключевое слово string представляет собой псевдоним для класса System, string, определенного библиотекой классов среды.NET Framework.