Тверской государственный университет
Опубликован: 02.12.2009 | Доступ: свободный | Студентов: 3204 / 514 | Оценка: 4.41 / 4.23 | Длительность: 11:54:00
ISBN: 978-5-9963-0259-8
Лекция 3:

Выражения и операции

Операции отношения

Операции отношения стоит просто перечислить, в объяснениях они не нуждаются. Всего операций 6 (==, !=, <, >, <=, >= ), все они возвращают результат логического типа bool. Операции перегружены, так что их операнды могут быть разных типов. Понятно, что перед вычислением отношения может потребоваться преобразование типа одного из операндов. Понятно, что не всегда возможны неявные преобразования, гарантирующие возможность выполнения сравнения. Возникнет ошибка на этапе компиляции в выражении:

1 > "1"

Задав явное преобразование типа для одного из операндов, это отношение можно вычислить. Следует обратить внимание на запись отношения эквивалентности, задаваемое двумя знаками равенства. Типичной ошибкой является привычная для математики запись:

if(a = b)

Выражение в скобках синтаксически корректно и воспринимается, как запись операции присваивания, допустимой в выражениях. К счастью, в большинстве случаев возникнет ошибка на этапе компиляции при попытке преобразования значения операнда b к типу bool. Но, если a и b - переменные логического типа, то никаких сообщений об ошибке выдаваться не будет, хотя результат выполнения может быть неправильным.

Операции проверки типов

Операции проверки типов is и as будут рассмотрены в последующих лекциях.

Операции сдвига

Операции сдвига вправо " >> " и сдвига влево " << " в обычных вычислениях применяются редко. Они особенно полезны, если данные рассматриваются, как строка битов. Результатом операции является сдвиг строки битов влево или вправо на K разрядов. В применении к обычным целым положительным числам сдвиг вправо равносилен делению нацело на 2^K, а сдвиг влево - умножению на 2^K. Для отрицательных чисел сдвиг влево и деление дают разные результаты, отличающиеся на 1. В языке C# операции сдвига определены только для некоторых целочисленных типов - int, uint, long, ulong. Величина сдвига должна иметь тип int. Вот пример применения этих операций:

/// <summary>
	///операции сдвига
	/// </summary>
	public void Shift()
	{
		int n = 17,m =3, p,q;
		p= n>>2; q = m<<2;
		Console.WriteLine("n= " + n + "; m= " +
			m + "; p=n>>2 = "+p + "; q=m<<2 " + q);
		long x=-75, y =-333, u,v,w;
		u = x>>2; v = y<<2; w = x/4;
		Console.WriteLine("x= " + x + "; y= " +
			y + "; u=x>>2 = "+u + "; v=y<<2 " + v +
			"; w = x/4 = " + w);
	}//Shift

Логические операции

Логические операции в языке C# делятся на две категории: одни выполняются только над операндами типа bool, другие - как над булевскими, так и над целочисленными операндами.

Логические операции над булевскими операндами

Операций, которые выполняются только над операндами булевского типа, три ( !, &&, ||). Высший приоритет среди этих операций имеет унарная операция отрицания ! x, которая возвращает в качестве результата значение, противоположное значению выражения x. Поскольку неявных преобразований типа к типу bool не существует, то выражение x задается либо переменной булевского типа, либо, как чаще бывает, выражением отношения. Возможна ситуация, когда некоторое выражение явным образом преобразуется к булевскому типу.

Следующая по приоритету бинарная операция ( x && y ) называется конъюнкцией, операцией "И" или логическим умножением. Она возвращает значение true в том и только в том случае, когда оба операнда имеют значение true. В остальных случаях возвращается значение false.

Следующая по приоритету бинарная операция ( x || y ) называется дизъюнкцией, операцией "ИЛИ" или логическим сложением. Она возвращает значение false в том и только в том случае, когда оба операнда имеют значение false. В остальных случаях возвращается значение true.

Когда описывается семантика операций, молчаливо предполагается, что операнды операции определены. Подразумевается, что результат операции не определен, если не определен хотя бы один из ее операндов. Это утверждение верно почти для всех операций языка C#. К исключениям относятся рассматриваемые нами логические операции && и ||. Эти операции называются условными логическими операциями. Если первый операнд операции конъюнкции && ложен, то второй операнд не вычисляется и результат операции равен false, даже если второй операнд не определен. Аналогично, если первый операнд операции дизъюнкции || истинен, то при выполнении этого условия второй операнд не вычисляется и результат операции равен true, даже если второй операнд не определен.

Ценность условных логических операций не в их эффективности по времени выполнения. Часто они позволяют вычислить имеющее смысл логическое выражение, в котором второй операнд не определен. Приведу в качестве примера классическую задачу поиска по образцу в массиве, когда в массиве разыскивается элемент с заданным значением (образец). Такой элемент может быть, а может и не быть в массиве. Вот типичное решение этой задачи:

//Условное And - &&
	public int SearchPattern(int[] arr, int pattern)
{
    int result = -1, index = 0;
    int n = arr.Length;
    while (index < n && arr[index] != pattern) index++;
    if (index != n) result = index;
    return (result);
}

Обратите внимание на выражение, задающее условие цикла while. Здесь условная конъюнкция выполняется над двумя отношениями. В том случае, когда образца нет в массиве, наступает момент, когда первый операнд становится ложным, в этот же момент второй операнд не определен, поскольку индекс проверяемого элемента массива выходит за допустимые пределы. Классическая конъюнкция должна в этот момент приводить к ошибке, возникновению исключительной ситуации. Но условная конъюнкция прекрасно справляется, и программа корректно работает во всех случаях.

Логические операции над булевскими операндами и целыми числами. Работа со шкалами

Рассмотрим логические операции, которые могут выполняться не только над булевскими значениями, но и над целыми числами. Высший приоритет среди этих операций имеет унарная операция отрицания ( ~x ). Заметьте: есть две операции отрицания, одна из них ( !x ) определена только над операндами булевского типа, другая ( ~x ) - только над целочисленными операндами.

Говоря о логических операциях над целыми числами, следует понимать, что целые числа можно рассматривать как последовательность битов (разрядов). Каждый бит, имеющий значение 0 или 1, можно интерпретировать как логическое значение обычным образом: 0 соответствует false, 1 - true. Логическая операция, применяемая к операндам одного и того же целочисленного типа, выполняется над соответствующими парами битов, создавая результат в виде последовательности битов и интерпретируемый как целое число. По этой причине такие логические операции называются побитовыми или поразрядными операциями.

Бинарных побитовых логических операций три - & , ^ , |. В порядке следования приоритетов это конъюнкция (операция "И"), исключающее ИЛИ, дизъюнкция (операция "ИЛИ"). Они определены как над целыми типами выше int, так и над булевыми типами. В первом случае они используются как побитовые операции, во втором - как обычные логические операции. Когда эти операции выполняются над булевскими операндами, то оба операнда вычисляются в любом случае, и если хотя бы один из операндов не определен, то и результат операции будет не определен. Когда необходима такая семантика логических операций, тогда без этих операций не обойтись.

Поразрядные логические операции определены не только над целыми числами, но и над перечислениями, которые проецируются на целочисленные типы. В реальных приложениях они чаще всего используются при работе со шкалами, часто представляемыми переменными перечислимого типа.

Шкалы

Побитовые логические операции широко применяются в реальном программировании при работе с так называемыми шкалами. Будем называть шкалой последовательность из n битов (n разрядов). Рассмотрим объект с n свойствами, каждым из которых объект может обладать или не обладать. Шкала позволяет однозначно задать, какими свойствами объект обладает, а какими нет. Пронумеруем свойства и будем записывать единицу в разряд с номером i, если объект обладает i-м свойством, и нуль - в противном случае.

Шкала позволяет экономно задавать информацию об объекте, а побитовые операции дают возможность весьма эффективно эту информацию обрабатывать. Поскольку эти операции определены над типами int, uint, long, ulong, C# может работать со шкалами длины 32 и 64.

Описание свойств объекта можно задать, используя перечисление - специальный тип данных, определяемый программистом. Свойства конкретного объекта, его шкалу можно задать переменной типа перечисление. При работе с такими переменными существенно используются поразрядные операции.

Рассмотрим содержательный пример. Пусть некоторая программистская фирма объявила прием на работу в фирме, предъявляя к претендентам такие требования: знание технологий и языков программирования. Возможный набор профессиональных свойств, которыми могут обладать претенденты на должность, можно задать перечислением:

// <summary>
    /// Свойства претендентов на должность программиста,
    /// описывающие знание технологий и языков программирования
    /// </summary>
    public enum Prog_Properties
    {
        VB = 1, C_sharp = 2, C_plus_plus = 4,
        Web = 8, Prog_1C = 16
    }

Заметьте, при определении перечисления можно указать, на какое значение целого типа проецируется значение из перечисления. Если проецировать i-е значение на i-й разряд целого числа (2^{i-1}), как это сделано в примере, то переменные перечисления будут задавать шкалу свойств.

Свойства каждого претендента на должность характеризуются своей шкалой, которую можно рассматривать как переменную типа Prog_Properties. Задать шкалу претендента можно целым числом в интервале от 0 до 2^n -1, приведя значение к нужному типу. Например, так:

Prog_Properties candidate1 = (Prog_Properties)18;

Согласно шкале, этот кандидат знает язык C# и умеет работать в среде 1С. Более естественно шкалу кандидатов задавать с использованием логических операций над данными перечисления. Например, так:

Prog_Properties candidate2 = Prog_Properties.C_sharp |
                Prog_Properties.C_plus_plus | Prog_Properties.Web;

Логические операции над шкалами позволяют эффективно реализовывать различные запросы, отбирая из массива кандидатов тех, кто соответствует заданным требованиям. Пусть, например, cand[i] - шкала i-го кандидата, а pattern - шкала, которая задает набор требований, предъявляемых к кандидатам. Рассмотрим условие:

(cand[i] & pattern) == pattern

Это условие будет истинным тогда и только тогда, когда кандидат соответствует всем требованиям, заданным в образце. Заметьте, скобки здесь необходимы, поскольку по умолчанию вначале бы выполнялась операция проверки на эквивалентность.

Этот простой пример показывает мощь аппарата шкал. Одно выражение с двумя операциями задает фильтр, позволяющий отобрать кандидата с нужными свойствами в условиях, когда число возможных свойств может быть велико. Без использования шкал потребовалось бы гораздо больше памяти и времени на достижение аналогичного результата.

Я написал отдельный класс Scales для работы со шкалами и перечислением Prog_Properties. Приведу несколько методов этого класса, позволяющих выполнять различные запросы к кандидатам.

/// <summary>
    /// Список кандидатов, которые обладают
    /// свойствами, заданными образцом.
    /// </summary>
    public ArrayList CandsHavePat()
    {
        ArrayList temp = new ArrayList();
        for (int i = 0; i < n; i++)
        if ((cand[i] & pattern) == pattern)
            temp.Add("cand[" + i + "]");
        return temp;
    }
       
    /// <summary>
    /// Список кандидатов, которые не обладают
    /// всеми свойствами, заданными образцом.
    /// </summary>
    public ArrayList CandsHaveNotAllPat()
    {
        ArrayList temp = new ArrayList();
        for (int i = 0; i < n; i++)
        if ((~cand[i] & pattern) == pattern)
            temp.Add("cand[" + i + "]");
        return temp;
    }
    /// <summary>
    /// Список кандидатов, которые обладают
    /// некоторыми свойствами, заданными образцом.
    /// </summary>
    public ArrayList CandsHaveSomePat()
    {
        ArrayList temp = new ArrayList();        
        for (int i = 0; i < n; i++)
        {
        currentScale = cand[i] & pattern;
        if (currentScale > 0 && currentScale < pattern)
            temp.Add("cand[" + i + "]");
        }
        return temp;
    }
    /// <summary>
    /// Список кандидатов, которые обладают
    /// только свойствами, заданными образцом.
    /// </summary>
    public ArrayList CandsHaveOnlyPat()
    {
        ArrayList temp = new ArrayList();
        for (int i = 0; i < n; i++)
        if (((cand[i] & pattern) == pattern) && 
            ((cand[i] & ~pattern) == 0))
            temp.Add("cand[" + i + "]");
        return temp;
    }

Все эти методы устроены одинаково. Они отличаются условием отбора в операторе if, которое включает побитовые логические операции, выполняемые над шкалами cand и pattern, объявленными как массив переменных, и простой переменной перечислимого типа Prog_Properties. В качестве результата выполнения запроса возвращается массив типа ArrayList, который содержит список кандидатов, удовлетворяющих условиям запроса. На рис. 3.4 показаны результаты работы консольного приложения, в котором используется созданный класс и вызываются приведенные выше методы этого класса.

Результаты запросов над шкалами

Рис. 3.4. Результаты запросов над шкалами
Дарья Федотова
Дарья Федотова
Надежда Савина
Надежда Савина

Записалась на платный курс Программирование на С# http://www.intuit.ru/studies/professional_retraining/951/video_courses/356/info. Оплату пока не производила.

Могу ли я скачать/прочитать текст прослушиваемых лекций? Особенно интересуют задания

Владимир Романов
Владимир Романов
Россия, Москва, МПУ им Н.К. Крупской