ch1 = (char) (ch1 + ch2);
Без приведения типов результат сложения операндов ch1 и ch2 будет иметь тип int, и поэтому его нельзя присвоить переменной типа char.
Продвижение типов происходит и при выполнении унарных операций, например с унарным минусом. Операнды унарных операций более мелкого типа, чем int (byte, sbyte, short и ushort), т.е. с более узким диапазоном представления чисел, продвигаются к типу int. То же самое происходит и с операндом типа char. Кроме того, если выполняется унарная операция отрицания значения типа uint, то результат продвигается к типу long.
Приведение типов в выражениях
Приведение типов можно применять и к отдельным частям крупного выражения. Это позволяет точнее управлять преобразованиями типов при вычислении выражения. Рассмотрим следующий пример программы, в которой выводятся квадратные корни чисел от 1 до 10 и отдельно целые и дробные части каждого числового результата. Для этого в данной программе применяется приведение типов, благодаря которому результат, возвращаемый методом Math.Sqrt(), преобразуется в тип int.
// Пример приведения типов в выражениях.
using System;
class CastExpr {
static void Main() {
double n;
for ( n = 1.0; n <= 10; n++) {
Console.WriteLine("Квадратный корень из {0} равен {1}",
n, Math.Sqrt(n));
Console.WriteLine("Целая часть числа: {0} ",
(int)Math.Sqrt(n));
Console.WriteLine("Дробная часть числа: {0} ",
Math.Sqrt(n) - (int)Math.Sqrt(n));
Console.WriteLine();
}
}
}
Вот как выглядит результат выполнения этой программы.
Квадратный корень из 1 равен 1
Целая часть числа: 1
Дробная часть числа: 0
Квадратный корень из 2 равен 1.4142135623731
Целая часть числа: 1
Дробная часть числа: 0.414213562373095
Квадратный корень из 3
равен 1.73205080756888
Целая часть числа: 1
Дробная часть числа: 0.732050807568877
Квадратный корень из 4 равен 2
Целая часть числа: 2
Дробная часть числа: 0
Квадратный корень из 5 равен 2.23606797749979
Целая часть числа: 2
Дробная часть числа: 0.23606797749979
Квадратный корень из 6 равен 2.44948974278318
Целая чaсть числа: 2
Дробная часть числа: 0.449489742783178
Квадратный корень из 7 равен 2.64575131106459
Целая часть числа: 2
Дробная часть числа: 0.645751311064591
Квадратный корень из 8 равен 2.82842712474619
Целая часть числа: 2
Дробная часть числа: 0.82842712474619
Квадратный корень из 9 равен 3
Целая часть числа: 3
Дробная часть числа: 0
Квадратный корень из 10 равен 3.16227766016838
Целая часть числа: 3
Дробная часть числа: 0.16227766016838
Как видите, приведение результата, возвращаемого методом Math.Sqrt(), к типу int позволяет получить целую часть числа. Так, в выражении
Math.Sqrt(n) - (int) Math.Sqrt(n)
приведение к типу int дает целую часть числа, которая затем вычитается из всего числа, а в итоге получается дробная его часть. Следовательно, результат вычисления данного выражения имеет тип double. Но к типу int приводится только значение, возвращаемое вторым методом Math.Sqrt().
ГЛАВА 4 Операторы
В языке C# предусмотрен обширный ряд операторов, предоставляющих программирующему возможность полного контроля над построением и вычислением выражений. Большинство операторов в C# относится к следующим категориям: арифметические, поразрядные, логические и операторы отношения. Все перечисленные категории операторов рассматриваются в этой главе. Кроме того, в C# предусмотрен ряд других операторов для_ особых случаев, включая индексирование массивов, доступ к членам класса и обработку лямбда-выражений. Эти специальные операторы рассматриваются далее в книге вместе с теми средствами, в которых они применяются.
Арифметические операторы
Арифметические операторы, представленные в языке С#, приведены ниже.
Оператор Действие
+ Сложение
- Вычитание, унарный минус
* Умножение
/ Деление
% Деление по модулю
- Декремент
++ Инкремент
Операторы +, * и / действуют так, как предполагает их обозначение. Их можно применять к любому встроенному числовому типу данных.
Действие арифметических операторов не требует особых пояснений, за исключением следующих особых случаев. Прежде всего, не следует забывать, что когда оператор / применяется к целому числу, то любой остаток от деления отбрасывается; например, результат целочисленного деления 10/3 будет равен 3. Остаток от этого деления можно получить с помощью оператора деления по модулю (%), который иначе называется оператором вычисления остатка. Он дает остаток от целочисленного деления. Например, 10 % 3 равно 1. В C# оператор % можно применять как к целочисленным типам данных, так и к типам с плавающей точкой. Поэтому 10.0 % 3.0 также равно 1. В этом отношении C# отличается от языков С и C++, где операции деления по модулю разрешаются только для целочисленных типов данных. В приведенном ниже примере программы демонстрируется применение оператора деления по модулю.
// Продемонстрировать применение оператора %.
using System;
class ModDemo {
static void Main() {
int iresult, irem;
double dresult, drem;
iresult = 10 / 3;
irem = 10 % 3;
dresult = 10.0 / 3.0;
drem = 10.0 % 3.0;
Console.WriteLine("Результат и остаток от деления 10/3: "
+ iresult + " " + irem);
Console.WriteLine("Результат и остаток от деления 10.0 / 3.0: "
+ dresult + " " + drem);
}
}
Результат выполнения этой программы приведен ниже.
Результат и остаток от деления 10/3: 3 1
Результат и остаток от деления 10.0 / 3.0: 3.33333333333333 1
Как видите, обе операции, % целочисленного типа и с плавающей точкой, дают один и тот же остаток, равный 1.
Операторы инкремента и декремента
Операторы инкремента (++) и декремента (-) были представлены в главе 2. Как станет ясно в дальнейшем, они обладают рядом особых и довольно интересных свойств. Но сначала выясним основное назначение этих операторов.
Оператор инкремента увеличивает свой операнд на 1, а оператор декремента уменьшает операнд на 1. Следовательно, оператор
х+ + ;
равнозначен оператору х = х + 1; а оператор
х--;
равносилен оператору
х = х - 1;
Следует, однако, иметь в виду, что в инкрементной или декрементной форме значение переменной х вычисляется только один, а не два раза. В некоторых случаях это позволяет повысить эффективность выполнения программы.
Оба оператора инкремента и декремента можно указывать до операнда (в префиксной форме) или же после операнда (в постфиксной форме). Например, оператор
х = х + 1;
может быть записан в следующем виде:
++х; // префиксная форма
или же в таком виде:
х++; // постфиксная форма
В приведенном выше примере форма инкремента (префиксная или постфиксная) особого значения не имеет. Но если оператор инкремента или декремента используется в длинном выражении, то отличие в форме его записи уже имеет значение. Когда оператор инкремента или декремента предшествует своему операнду, то результатом операции становится значение операнда после инкремента или декремента. А когда оператор инкремента или декремента следует после своего операнда, то результатом операции становится значение операнда до инкремента или декремента. Рассмотрим следующий фрагмент кода.
х = 10;
у = ++х;
В данном случае значение переменной у будет установлено равным 11, поскольку значение переменной х сначала увеличивается на 1, а затем присваивается переменной у. Но во фрагменте кода
х = 10;
у = х++;
значение переменной у будет установлено равным 10, так как в этом случае значение переменной х сначала присваивается переменной у, а затем увеличивается на 1. В обоих случаях значение переменной х оказывается равным 11. Отличие состоит лишь том, когда именно это значение станет равным 11: до или после его присваивания переменной у.
Возможность управлять моментом инкремента или декремента дает немало преимуществ при программировании. Обратимся к следующему примеру программы, в которой формируется последовательный ряд чисел.
// Продемонстрировать отличие между префиксной
// и постфиксной формами оператора инкремента (++).
using System;
class PrePostDemo {
static void Main() {
int x, y;
int i;
x = 1;
y = 0;
Console.WriteLine("Ряд чисел, полученных " +
"с помощью оператора у = у + х++;");
for(i = 0; i < 10; i++) {
y = y + x++; // постфиксная форма оператора ++
Console.WriteLine(y + " ");
}
Console.WriteLine();
x = 1;
y = 0;
Console.WriteLine("Ряд чисел, полученных " +
"с помощью оператора у = у + ++х;");
for(i = 0; i < 10; i++) {
y = y + ++x; // префиксная форма оператора ++
Console.WriteLine(y + " ");
}
Console.WriteLine();
}
}
Выполнение этой программы дает следующий результат.
Ряд чисел, полученных с помощью оператора у = у + х++
1
3
б
10
15
14
21
28
36
45
55
Ряд чисел, полученных с помощью оператора у = у + ++х;
2
5
9
14
20
27
35
44
54
65
Как подтверждает приведенный выше результат, в операторе
у = у + х++;
первоначальное значение переменной х складывается с самим собрй, а полученный результат присваивается переменной у. После этого значение переменной х увеличивается на 1. Но в операторе
у = у + ++;
значение переменной х сначала увеличивается на 1, затем складывается с первоначальным значением этой же переменной, а полученный результат присваивается переменной у. Как следует из приведенного выше результата, простая замена префиксной формы записи оператора ++х постфиксной формой х++ приводит к существенному изменению последовательного ряда получаемых чисел.
И еще одно замечание по поводу приведенного выше примера: не пугайтесь выражений, подобных следующему:
у + ++х;
Такое расположение рядом двух операторов может показаться не совсем привычным, но компилятор воспримет их в правильной последовательности. Нужно лишь запомнить, что в данном выражении значение переменной у складывается с увеличенным на 1 значением переменной х.
Операторы отношения и логические операторы
В обозначениях оператор отношения и логический оператор термин отношения означает взаимосвязь, которая может существовать между двумя значениями, а термин логический - взаимосвязь между логическими значениями "истина' и "ложь". И поскольку операторы отношения дают истинные или ложные результаты, то они нередко применяются вместе с логическими операторами. Именно по этой причине они и рассматриваются совместно в данном разделе.
Ниже перечислены операторы отношения.
Оператор Значение
== Равно
!= Не равно
> Больше
< Меньше
>= Больше или равно
<= Меньше или равно
К числу логических относятся операторы, приведенные ниже.
Оператор Значение
& И
| ИЛИ
^ Исключающее ИЛИ
&& Укороченное И
|| Укороченное ИЛИ
! НЕ
Результатом выполнения оператора отношения или логического оператора является логическое значение типа bool.