Жанр: Учеба
Си шарп: создание приложений для windows
...guage Specification) и
отображаются на основные типы платформы .NET. Это гарантирует, что
объекты, созданные на С#, могут успешно использоваться наряду с объектами,
созданными на любом другом языке программирования, поддерживающем
.NET CLS (например, VB.NET).
Каждый тип имеет строго заданный для него размер, который не может
изменяться. В отличие от языка C++, в С# тип int всегда занимает 4 байта,
потому что отображается к Int32 в .NET CLS. Представленная ниже
таблица содержит список всех встроенных типов, предлагаемых С#.
Тип
sbyte
byte
char
bool
short
ushort
int
uint
long
ulong
float
double
decimal
Область значений
-128 ДО 127
0 до 255
U + 0000 до U + fflT
true или false.
-32,768 до 32,767
0 до 65,535
-2,147,483,648 до 2,147,483,647
0 ДО 4,294,967,295
-9,223,372,036,854,775,808 ДО
9,223,372,036,854,775,807
0 до 18,446,744,073,709,551,615
±1.5-КН6 ДО ±3.4 .10(tm)
±5.0-Ю"3 2 4 до ±1.7 -lO3 0 8
Размер
Знаковое 8-бит целое
Беззнаковое 8-бит целое
16-битовый символ Unicode
1 байт
Знаковое 16-бит целое
Беззнаковое 16-бит целое
Знаковое 32-бит целое
Беззнаковое 32-бит целое
Знаковое 32-бит целое
Беззнаковое 32-бит целое
4 байта, точность - 7 разрядов
8 байт, точность -16 разрядов
12 байт, точность - 28 разрядов
В дополнение к этим примитивным типам С# может иметь объекты
типа enum и struct (см. ниже).
54 Раздел I I . Фундаментальные понятия
Преобразование встроенных типов
Объекты одного типа могут быть преобразованы в объекты другого
типа неявно или явно. Неявные преобразования происходят автоматически,
компилятор делает это вместо вас. Явные преобразования осуществляются,
когда вы "приводите" значение к другому типу. Неявные преобразования
гарантируют также, что данные не будут потеряны. Например,
вы можете неявно приводить от short (2 байта) к int (4 байта).
Независимо от того, какой значение находится в short, оно не потеряется
при преобразовании к int:
short x = 1;
int у = х;//неявное преобразование
Если вы делаете обратное преобразование, то, конечно же, можете
потерять информацию. Если значение в int больше, чем 32.767, оно будет
усечено при преобразовании. Компилятор не станет выполнять неявное
преобразование от int к short:
short х;
int у - 5;
х = у; //не скомпилируете^
Вы должны выполнить явное преобразование, используя оператор
приведения:
short х;
int у - 5;
х = (short) у;//OK
ПЕРЕМЕННЫЕ
Переменная - это расположение в памяти объекта определенного типа.
В приведенных выше примерах х и у - переменные. Переменные могут
иметь значения, которыми они проинициализированы, или эти значения
могут быть изменены программно.
Назначение значений переменным
Чтобы создать переменную, вы должны задать тип переменной и затем
дать этому типу имя. Вы можете проинициализировать переменную во время
ее объявления или присвоить ей новое значение во время вьшолнения программы.
Вот пример программы, который в первом случае использует инициализацию
для присвоения значения переменной, во втором случае использует
присвоение значения переменной с помощью оператора "=":
class Variables
static void Main()
{
int mylnt = 10;
Типы данных С# 55
Syste.T.. Console .WriteLine ( "Инициализированная переменная mylnt: { 0 } ",
my In r.) ;
myIn z = 5;
System.Console.WriteLine("mylnt после присвоения значения: {0(",
rr.ylnt) ;
i
Результат работы этой программы будет следующий:
Инициализированная переменная mylnt: 10
mylnt после присвоения значения: 5
Здесь строка:
int mylrt = 10;
означает объявление и инициализацию переменной mylnt. Строка:
my I n г. - 5 ;
означает присвоение переменной mylnt значения 5.
Определение значений переменных
С# требует определения значений, то есть переменные перед использованием
должны быть инициализированы. Чтобы проверить это правило,
давайте рассмотрим следующий пример:
class Variables
snatic void Kain()
{
int rayInt;
System.Console.WriteLine("Initialized, mylnt: {0}",
mylnt);
mylnt - 5;
System.Console.WriteLine("After assignment, mylnt: {0}",
mylnt);
Если вы попробуете скомпилировать этот пример, компилятор отобразит
следующее сообщение об ошибке:
error CS3165: Use of unassigned local variable 'mylnt'
Нельзя использовать неинициализированную переменную в С#. У вас
может сложиться впечатление, что вы должны инициализировать каждую
переменную в программе. Это не так. Вы должны лишь назначить
переменной значение прежде, чем попытаетесь ее использовать. Ниже
представлен пример правильной программы без использования инициализации
переменной mylnt.
class Variables
{
static void Main()
56 Раздел I I . Фундаментальные понятия
int mylnt;
mylnt: - 1С;
System.Console.WriteLine("Initialized, mylnt: {0}",
mylnt];
mylnt - 5;
System.Console.WriteLine("After assignment, mylnt: {0}",
mylnt];
i
}
В данном примере вместо инициализации выбирается присвоение значения
переменной mylnt до ее использования:
mylnt = 10;
КОНСТАНТЫ
Константа - это переменная, значение которой не может быть изменено.
Переменные - это более гибкий способ хранения данных. Однако иногда
вы хотите гарантировать сохранение значения определенной переменной.
Например, число pi. Как известно, значение этого числа никогда не изменяется.
Следовательно, вы должны гарантировать, что переменная, хранящая
это число, не изменит своего значения на протяжении всей работы программы.
Ваша программа будет лучше читаемой, если вы вместо записи:
у - х * 3.1415926535897932384626433832795
будете использовать переменную, которая хранит значение pi. В таком
случае используемой переменной должна быть константа:
const double pi - 3.1415926535897932384626433832795;
у ^ х * pi;
Существует три разновидности константы: литералы, символические
константы и перечисления. Рассмотрим следующий случай:
х = 100;
Значение 100 - это литеральная константа. Значение 100 -это всегда
100. Вы не можете установить новое значение на 100. Вы не можете сделать
так, чтобы 100 представляло значение 99. Символические константы
устанавливают имя для некоторого постоянного значения. Вы объявляете
символическую константу, используя ключевое слово const, и применяете
следующий синтаксис для создания константы:
const тип идентификатор = значение;
Константа обязательно должна быть проинициализирована, и ее значение
не может быть изменено во время выполнения программы. Например:
const double pi = 3.1415926535897932384626433832795;
pi - 5.0; //недопустимая операция
В этом примере число 3.14...-литеральная константа, a pi - символическая
константа типа double. Ниже представлен пример использования
символических констант.
Типы данных С# 57
class Constants
{
static void Main О
const in: pi = 3.1415926535897932384626433832795;
const in" g = 9.81; //гравитационная постоянная
System.Console.WriteLine{"Число пи: {0}" ,
pi);
Syseem.Console.WriteLine("Гравитационная постоянная: {0}",
g);
Результат работы программы будет следующий:
Число pi: 3.1415926535897932384626433832795
Гравитационная постоянная: 9.81
В последнем примере создаются две символические целочисленные
константы: pi и д. Эти константы преследуют ту же цель, что и использование
их литеральных значений. Но данные константы имеют имена,
которые несут в себе гораздо больше информации об используемом значении,
чем просто набор цифр.
Для того чтобы убедиться, что константные значения не могут быть изменены
во время выполнения программы, добавьте в код следующую строку:
д - 10;
Во время компиляции вы получите следующее сообщение об ошибке:
error CS0131: The left-hand side of an assignment must be a variable,
property or indexer.
ПЕРЕЧИСЛЕНИЯ
Перечисления являются мощной альтернативой константам. Это особый
тип значений, который состоит из набора именованных констант.
Допустим, у вас есть список констант, содержащих годы рождения ваших
знакомых. Для того чтобы запрограммировать это при помощи констант,
вам придется написать:
const intfloat maryBirthday = 1955;
const intfloat ivanBirthday =- 1980;
const intfloat pavelBirthday - 1976;
У вас получились три совершенно несвязанные константы. Для того
чтобы установить логическую связь между ними, в С# предусмотрен
механизм перечислений. Вот как выглядит тот же код, записанный при
помощи перечислений:
enum FriendsBirthday
f
const flcat maryBirthday - 1955;
58 Раздел I I . Фундаментальные понятия
const float ivanBirthday - 1980;
const float pavelBirthday - 1976;
}
Теперь две символические константы являются элементами одного
перечисления типа FriendsBirthday.
Каждое перечисление имеет свой базовый тип, которым может быть
любой встроенный целочисленный тип С# (int, long, short и т. д.), за исключением
char.
Перечисление задается следующим образом:
[атрибуты] [модификаторы] enum идентификатор[: базовый тип] ( список перечислений);
Атрибуты и модификаторы рассматриваются далее в этой книге. Пока
давайте остановимся на второй части этого объявления. Перечисление
начинается с ключевого слова enum, которое сопровождается идентификатором
типа:
enum MyEnurnerators
Базовый тип - основной тип для перечисления. Если вы не учитываете
этот описатель при создании перечисления, то будут использоваться значения
по умолчанию int. Но вы можете применить любой из целочисленных
типов (например, ushort, long), за исключением char. Например, следующий
фрагмент кода объявляет перечисление целых чисел без знака (uint):
enum Sizes: uint.
{
Small - 1,
Middle- 2,
Large - 3
}
Внутри каждого перечисления записывается список возможных значений
перечисления, разделенных запятой. Каждое значение может представлять
собой либо просто набор символических констант, либо набор
символических констант в сочетании с литеральным целочисленным
значением. Если вы не укажете для элементов перечисления целочисленных
значений, то компилятор пронумерует их сам, начиная с 0. Например,
следующие фрагменты кода аналогичны:
enum Sizes
(
Small = 0,
Middie= 1,
Large = 2
}
И
enum Sizes
Small,
Kiddle,
Large
Типы данных С# 59
Если вы объявите свое перечисление следующим образом:
enum Sizes
[
Small,
Middle-20,
Large
i
то элементы перечисления будут иметь такие числовые значения:
Small = 0;
Middle = 20;
Large = 21.
Давайте рассмотрим пример, который наглядно показывает, каким
образом перечисления помогают упростить код приложения.
class Sc:;eeriResolutions
//перечисление размеров мониторов в дюймах
enum Screens
(
Small = 14,
Medium = 17,
Large - 19,
SuperLarge -; 21,
static void Main! }
System.Console.WriteLine("Самые маленькие мониторы имеют размер: {0}
(int) Screens.Small );
System.Console.WriteLine("Самые большие мониторы имеют размер: {0}",
(int) Screens.SuperLarge);
Как видите, значение перечисления (SuperLarge) должно быть специфицировано
именем перечисления (Screens). По умолчанию, значение
перечисления представляется его символическим именем (типа Small или
Medium). Если вы хотите отобразить значение константы перечисления,
то должны привести константу к ее основному типу (в данном случае int).
Целочисленное значение передается в функцию WriteLine, и оно отображается
на экране.
Строковые константы
Для объявления в программе константной строки вам необходимо заключить
содержимое строки в двойные кавычки ("My string"). Вы можете
делать это практически в любом месте программы: в передаче парамет60
Раздел I I . Фундаментальные понятия
ров функции, в инициализации переменных. Мы уже неоднократно применяли
строковые константы при выводе данных на экран.
System.Console.WriteLine("Самые большие мониторы имеют размер: {С}",
(int) Screens.SuperLarge);
Здесь в качестве одного из параметров функции используется строка
"Самые большие мониторы имеют размер: {0}".
string strMessage = "Здравствуй Мир!";
В данном случае константная строка "Здравствуй Мир!" инициализирует
переменную strMessage.
МАССИВЫ
Более детально работа с массивами будет рассмотрена в главе 12. Пока
я лишь хочу рассказать о массивах с точки зрения типов данных.
Массивы в С# несколько отличаются от других С-подобных языков.
Начнем сразу с примеров. Пример первый:
int [ ] к; //к - массив
k-new int [3]; //Определяем массив из 3 целых
к[0]=-5; к[1]-4; к[2]=55; //Задаем элементы массива
//Выводим третий элемент массива
Console.WriteLine{к[2] .ToString f));
Смысл приведенного фрагмента ясен из комментариев. Обратите внимание
на некоторые особенности. Во-первых, массив определяется именно
как
int[1 к;
а не как один из следующих вариантов:
int k[); //Неверно!
int k [?") ; //Неверно !
int f3] к; //Неверно!
Во-вторых, так как массив представляет собой ссылочный объект, то
для создания массива необходима строка
k^new int [3];
Именно в ней мы и определяем размер массива. Кроме того, возможны
конструкции вида
i n t П k = new i n t [3] ;
Элементы массива можно задавать сразу при объявлении. Например:
intП к = {-5, 4, 55} ;
Разумеется, приведенные конструкции применимы не только к типу
int и не только к массиву размера 3.
В С#, как и в C/C++, нумерация элементов массива идет с нуля. Таким
образом, в нашем примере начальный элемент массива - это k[0], a
последний - к[2]. Элемента к[3], естественно, нет.
Теперь переходим к многомерным массивам. Вот так задается двумерный
массив:
i n t f , | k = new i n t [ 2 , 3 ] ;
Типы данных С# 61
Обратите внимание, что пара квадратных скобок только одна. В нашем
примере у массива 6 (=2*3) элементов (к[0,0] - первый, к[1,2] - последний).
Аналогично мы можем задавать многомерные массивы. Вот пример
трехмерного массива:
i n t [ , , J к - new i n t [10,10,10];
А вот так можно сразу инициализировать многомерные массивы:
i n t [ , ] л = { { 2 , - 2 ) , { 3 , - 2 2 ] , { 0 , 4 } ) ;
Приведенные выше примеры многомерных массивов называются прямоугольными.
Если их представить в виде таблицы (в двумерном случае),
то массив будет представлять собой прямоугольник.
Наряду с прямоугольными массивами существуют так называемые
ступенчатые. Вот пример:
//Объявляем 2-мерный ступенчатый массив
int[] Гi k = new int [2][];
//Объявляем 0-й элемент нашего ступенчатого массива
//Это опять массив и в нем 3 элемента
k[0]=new int[3];
//Объявляем 1-й элемент нашего ступенчатого массива
//Это опять массив и в нем 4 элемента
k[l]=new int [4];
к[1][3]=22; //записываем 22 в последний элемент массива
Обратите внимание, что у ступенчатых массивов мы задаем несколько
пар квадратных скобок (по размерности массива). И точно так же мы
что-нибудь делаем с элементами массива - записываем, читаем и т. п.
Самая важная и интересная возможность ступенчатых массивов - это
их "непрямоугольность". Так, в приведенном выше примере в первой
"строке" массива к три целых числа, а во второй - четыре. Часто это
оказывается очень кстати.
6. ВЫРАЖЕНИЯ, ИНСТРУКЦИИ
И РАЗДЕЛИТЕЛИ
ВЫРАЖЕНИЯ (Expressions)
Выражение - это строка кода, которая определяет значение. Пример
простого выражения:
myValue - 100;
Обратите внимание, что данная инструкция выполняет присвоение
значения 100 переменной myValue. Оператор присвоения (=) не сравнивает
стоящее справа от него значение (100) и значение переменной, которая
находится слева от оператора (myValue). Оператор "=" устанавливает
значение переменной myValue равным 100.
Поскольку myValue = 100, то как выражение, которое определяет значение
100, myValue может использоваться другим оператором присвоения.
Например:
rr.ySecondValue - myValue - 100;
В данном выражении литеральное значение 100 присваивается переменной
myValue, а затем оператором присвоения устанавливается вторая
переменная mySecondValue с тем же значением 100. Таким образом, значение
100 будет присвоено обеим переменным одновременно. Инструкцией
такого вида вы можете инициализировать любое число переменных с
одним и тем же значением, например 20:
a = b - c = d - e = 2 0 ;
ИНСТРУКЦИИ (Statements)
Инструкция - это законченное выражение в коде программы. Программа
на языке С# состоит из последовательностей инструкций. Каждая инструкция
обязательно должна заканчиваться точкой с запятой (;). Например:
in: x; II инструкция
х - 100; //другая инструкция
int, у - х; //тоже инструкция
Кроме того, в С# существуют составные инструкции. Они, в свою очередь,
состоят из набора простых инструкций, помещенных в фигурные
скобки ( { } ).
{
inn x; // инструкция
х - 100; //другая инструкция
Типы данных С# 63
int у = х; //тоже инструкция
В этом примере все три инструкции являются элементами одной инструкции.
С# инструкции рассматриваются в соответствии с порядком их записи
в тексте программы. Компилятор начинает рассматривать код программы
с первой строки и заканчивает концом файла.
РАЗДЕЛИТЕЛИ (Delemiters)
В языке С# пробелы, знаки табуляции и переход на новую строку
рассматриваются как разделители. В инструкциях языка С# лишние разделители
игнорируются. Таким образом, вы можете написать:
myVaiue = 100;
или:
myVaiue - 100;
Компилятор обработает эти две инструкции как абсолютно идентичные.
Исключение состоит в том, что пробелы в пределах строки не игнорируются.
Если вы напишете:
Console.WriteLine("Здравствуй Мир !");
каждый пробел между словами "Здравствуй", "Мир" и знаком "!" будет
обрабатываться как отдельный символ строки.
В большинстве случаев использование пробелов происходит чисто
интуитивно. Обычно они применяются для того, чтобы сделать программу
более читаемой для программиста; для компилятора разделители
абсолютно безразличны.
Надо заметить, что есть случаи, в которых использование пробелов
является весьма существенным. Например, выражение:
int myVaiue = 25;
то же самое, что и выражение:
int myValue=25;
но следующее выражение не будет соответствовать двум предыдущим:
intmyValue =25;
Компилятор знает, что пробел с обеих сторон оператора присвоения
игнорируется (сколько бы много их не было), но пробел между объявлением
типа int и именем переменной myVaiue должен быть обязательно.
Это не удивительно, пробелы в тексте программы позволяют компилятору
находить и анализировать ключевые слова языка. В данном случае
это int, а некоторый термин intmyValue для компилятора неизвестен. Вы
можете свободно добавлять столько пробелов, сколько вам нравится, но
между int и myVaiue должен быть, по крайней мере, один символ пробела
или табуляции.
7. ВЕТВЛЕНИЕ ПРОГРАММ
Для того чтобы программы на С# были более гибкими, используются
операторы перехода (операторы ветвления). В С# есть два типа ветвления
программы: безусловный переход и условный.
Кроме ветвлений, в С# также предусмотрены возможности циклической
обработки данных, которые определяются ключевыми словами: for,
while, do, in и foreach. Эти операторы будут обсуждаться в главе "Циклическая
обработка данных". Пока давайте рассмотрим некоторые из основных
способов условного и безусловного перехода.
БЕЗУСЛОВНЫЕ ПЕРЕХОДЫ
Безусловный переход осуществляется двумя способами.
Первый способ - это вызов функций. Когда компилятор находит в
основном тексте программы имя функции, то происходит приостановка
выполнения текущего кода программы и осуществляется переход к найденной
функции. Когда функция выполнится и завершит свою работу, то
произойдет возврат в основной код программы, на ту инструкцию, которая
следует за именем функции. Следующий пример иллюстрирует безусловный
переход с использованием функции:
using System;
class Functions
{
static void Main( )
{
Console.WriteLine("Метод Main. Вызываем метод Jump...");
Jump ( | ;
Console.WriteLine ("Возврат в метод Main.");
}
static void Jump( )
{
Console.WriteLine("Работает метод Jump!");
}
Откомпилируйте и запустите программу. Вы увидите результат ее
работы:
Метод Main. Вызываем метод Jump...
Работает метод Jump!
Возврат в метод Main.
Ветвление программ 65
Программа начинает выполняться с метода Main() и осуществляется
последовательно, пока компилятор не вызовет функцию Jump(). Таким
образом, происходит ответвление от основного потока выполняемых инструкций.
Когда функция Jumpf) заканчивает свою работу, то продолжается
выполнение программы со следующей строки после вызова функции.
Второй способ реализации безусловного перехода можно осуществить
при помощи ключевых слов: goto, break, continue, return или throw. Дополнительная
информация об инструкциях goto, break, continue и return будет
рассмотрена ниже в этой главе. Об инструкции throw мы поговорим в
главе "Обработка исключений".
УСЛОВНЫЕ ПЕРЕХОДЫ
Условный переход можно реализовать в программе с помощью ключевых
слов языка: if, else или switch. Такой переход возможен только при
условии, если он является истинным.
if...else оператор
if...else - это оператор ветвления, работа которого определяется условием.
Условие оператора анализируется инструкцией if. Если условие верно
(true), то выполняется блок инструкций программы, описанных после
условия.
if ( expression ) statement 1
[else statement2 ]
Такой вид этого оператора вы можете найти в документации по С#.
Он показывает, что работа условного оператора определяется булевым
выражением (выражение, которое имеет значение true или false) в круглых
скобках. Если значение этого выражения истинно, то выполняется
блок инструкций statementl. Если же выражение ложно, произойдет выполнение
блока инструкций statement2. Необходимо заметить, что вторая
часть оператора (else statement^) может не указываться. Если инструкций
в блоках statementl или statement2 больше одной, то блок обязательно
нужно брать в фигурные скобки.
using System;
class Conditional
static void Mainf )
{
int valueOne = 20;
//устанавливаем второе значение больше первого
int valueTwo = 10;
if ( valueOne " valueTwo )
Console.WriteLine f
66 Раздел II. Фундаментальные понятия
"valueOne: {0} больше чем valueTwo: fl}",
valueOne, valueTwo);
else
Console.WriteLine(
"valueTwo: {0} больше или равно valueOne: {1}",
valueTwo, valueOne);
//устанавливаем первое значение больше второго
valueTwo = 30;
if ( valueOne " valueTwo )
{
Console.WriteLine(
"valueOne: {0} больше чем valueTwo: (1)",
valueOne, valueTwo);
i
//делаем значения одинаковыми
valueOne = valueTwo;
iffvalueOne =" valueTwo)
{
Console.WriteLine (
"valueOne и valueTwo равны: {0}=={1}",
valueOne, vaiueTwo);
}
}
}
Операторы сравнения: больше чем ("), меньше чем (") или равно (==)
достаточно понятны и просты в использовании.
В этом примере первый оператор if проверяет значение переменной
valueOne относительно значения переменной valueTwo. Если значение
valueOne больше значения переменной valueTwo (valueOne будет равным
20, a valueTwo будет равным 10), то условие оператора (valueOne " valueTwo)
является истинным и на экране появится строка:
valueOne: 10 больше чем valueTwo: 1
Во втором операторе if условие осталось прежним, но значение valueTwo
уже изменилось на 30. Поэтому условие оператора (valueOne " valueTwo)
является ложным и результат не будет отображен на экране.
Последний оператор условия проверяет равенство двух значений (valueOne
== valueTwo). А поскольку перед этим мы приравняли две переменные, то
результат проверки будет истинным. И на экране появится информация:
valueOne и valueTwo равны: 30=-30
Результатом работы программы будет следующая информация:
valueTwo: 20 больше или равно valueOne: 10
valueOne и valueTwo равны: 30==30
Ветвление программ 67
Вложенные операторы условия
Для обработки сложных условий возможно вложение условных операторов
в блоки инструкций других условных операторов. Например, вам
необходимо оценить рабочую температуру воздуха в офисе и выдать сообщение
пользователю.
Если значение температуры больше 21° и меньше 26°, то температура
находится в пределах нормы. Если же температура равна 24°, то выдается
сообщение о том, что рабочий климат оптимален.
Есть много способов написать такую программу. Приведем пример,
иллюстрирующий один из способов, в котором используется вложенность
оператора if...else:
using System;
class Values
{
static void Main( )
{
int temp = 25;
if (temp " 21)
{
if (temp " 26)
{
Console.WrireLine (
"Температура находится в пределах нормы");
if (temp == 24)
{
Console.WriceLine("Рабочий климат оптимален");
)
else
{
Console .WriteLine ("Рабочий климат не оптимален\п" -1"Оптимальная
температура 24");
1
В теле программы встречается два условных оператора if...else. В первом
операторе происходит проверка на попадание значения температуры
в нижний предел (21°). Значение temp больше, чем 21, значит условие
(temp " 21) истинное и выполнится следующая проверка. Во втором операторе
происходит проверка на попадание значения температуры в верхний
предел (26°). Значение temp равно 24, значит, условие (temp " 26)
истинное и будет выполняться блок инструкций в фигурных скобках.
Таким образом, уже выяснилось, что температура в пределах нормы, и
68 Раздел I I . Фундаментальные понятия
остается узнать, является ли она оптимальной - это и реализует последний
оператор if. Значение temp равно 25°, значит, условие (temp == 24)
последнего оператора ложно и на экране появится сообщение:
Температура находится в пределах нормы
Рабочий климат не оптимален.
Оптимальная температура 25
Заметьте, что в условном операторе в круглых скобках стоит два знака
равно:
if(tempValue == 24)
Если бы тут стоял один знак, то такую ошибку было бы трудно заметить.
И результатом такого выражения стало бы присвоение переменной
temp значения 24. В С и С ++ любое значение, отличное от нуля, определяется
как булева истина (true), следовательно, условный оператор вернул
бы истину, и на экране вывелась бы строка "Рабочий климат не
оптимален". Таким образом, действие выполнилось бы неправильно, а
побочным эффектом стало бы нежелательное изменение значения temp.
Впоследствии у разработчика могли бы возникать непредвиденные ошибки
работы программы!
С# требует, чтобы условные операторы принимали в качестве условий
только булевы значения. Поэтому, если бы такая ошибка возникла, то
компилятор не смог бы преобразовать выражение temp = 24 к булеву
типу и выдал бы сообщение об ошибке в процессе компиляции программы.
Это является достоинством по сравнению с C++, так как разрешается
проблема неявных преобразований типов данных, в частности целых
чисел и булева типа!
Использование составных инстр
...Закладка в соц.сетях
