Классы

Методы-свойства

Методы, называемые свойствами ( Properties ), представляют специальную синтаксическую конструкцию, предназначенную для обеспечения эффективной работы со свойствами. Напомню, правильной стратегией является закрытие полей от клиента - поля объявляются с модификатором protected или private. Клиенты класса не должны использовать информацию о том, как устроены поля. Это облегчает возможную модификацию класса в будущем. Класс сможет изменить представление данных, сохранив интерфейс, предоставляемый клиентам. В этом случае изменения в полях не отразятся на клиентах.

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

Для эффективной поддержки этих стратегий и введены специальные методы, называемые свойствами. Приведу вначале пример, а потом уточню синтаксис этих методов. Рассмотрим класс Person, у которого пять полей: fam, status, salary, age, health, характеризующих, соответственно, фамилию, статус, зарплату, возраст и здоровье персоны. Все поля закрыты для клиента, так что клиент не может непосредственно читать или записывать данные в поля класса. Для каждого из этих полей может быть разумной своя стратегия доступа. При проектировании класса будем предполагать, что возраст доступен для чтения и записи, фамилию можно задать только один раз, статус можно только читать, зарплата недоступна для чтения, а здоровье закрыто для доступа и только специальные методы класса могут сообщать некоторую информацию о здоровье персоны. Вот как на C# можно обеспечить эти стратегии доступа к закрытым полям класса:

/// <summary>
/// Класс, задающий общие свойства 
/// и поведение личности
/// </summary>
public class Person
{
   public enum Status
    {
        ребенок, школьник,
        студент, работник, пенсионер
    }
    //поля (все закрыты)
    string fam = "",  health = "";
    int age = 0, salary = 0;
    Status status = Status.работник;
    //методы - свойства
    /// <summary>
    ///стратегия: Read,Write-once (Чтение, запись при первом обращении)
    /// </summary>
    public string Fam
    {
        set { if (fam == "") fam = value; }
        get { return (fam); }
    }
    /// <summary>
    ///стратегия: Read-only(Только чтение)
    /// </summary>
    public Status GetStatus
    {
        get { return (status); }
    }
    /// <summary>
    ///стратегия: Read,Write (Чтение, запись)
    /// </summary>
    public int Age
    {
        set
        {
            age = value;
            //Изменение статуса
            if (age < 7) status = Status.ребенок;
            else if (age < 17) status = Status.школьник;
            else if (age < 22) status = Status.студент;
            else if (age < 65) status = Status.работник;
            else status = Status.пенсионер;
        }
        get { return (age); }
    }
    /// <summary>
    ///стратегия: Write-only (Только запись)
    /// </summary>
    public int Salary
    {
        set { salary = value; }
    }
}

Рассмотрим теперь общий синтаксис методов-свойств. Пусть name - это закрытое свойство. Тогда для него можно определить открытый метод-свойство (функцию), возвращающую тот же тип, что и поле name. Имя метода обычно близко к имени поля, отличаясь от него, например, только заглавной буквой ( Name ). Тело свойства содержит два метода - get и set, один из которых может быть опущен. Метод get возвращает значение закрытого поля, метод set устанавливает значение, используя значение, передаваемое ему в момент вызова и хранящееся в служебной переменной со стандартным именем value. Поскольку get и set - это обычные процедуры языка, программно можно реализовать сколь угодно сложные стратегии доступа. В нашем примере фамилия меняется, только если ее значение равно пустой строке, и это означает, что фамилия персоны ни разу еще не задавалась. Статус персоны пересчитывается автоматически при всяком изменении возраста, явно изменять его нельзя. Вот пример, показывающий, как некоторый клиент создает поля персоны и работает с ними:

/// <summary>
/// Тестирование свойств объектов
/// класса Person
/// </summary>
public void TestPersonProps()
{           
    Person pers1 = new Person(), 
           pers2 = new Person();
    pers1.Fam = "Хохлова";
    pers1.Age = 21;
    ConsolePrintPerson(pers1);           
    pers2.Fam = "Петров"; 
    pers2.Age = pers1.Age + 1;
    ConsolePrintPerson(pers2);
    pers1.Fam = "Петрова";
    ConsolePrintPerson(pers1);
}//TestPersonProps
/// <summary>
/// Вывод на консоль полей, открытых для чтения
/// </summary>
void ConsolePrintPerson(Person pers)
{
    Console.WriteLine("Фам={0}, возраст={1}, статус={2}",
        pers.Fam, pers.Age, pers.GetStatus);
}

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

Индексаторы

Свойства являются частным случаем метода класса с особым синтаксисом. Еще одним частным случаем является индексатор. Метод-индексатор является обобщением метода-свойства. Он обеспечивает доступ к закрытому полю, представляющему массив. Объекты класса индексируются по этому полю.

Синтаксически объявление индексатора такое же, как и в случае свойств, но методы get и set приобретают аргументы по числу размерности массива, задающего индексы элемента, значение которого читается или обновляется. Важным ограничением является то, что у класса может быть только один индексатор и у этого индексатора стандартное имя this. Так что если среди полей класса есть несколько массивов, то индексация объектов может быть выполнена только по одному из них.

Добавим в класс Person свойство children, задающее детей персоны, сделаем это свойство закрытым, а доступ к нему обеспечит индексатор:

const int Child_Max = 20; //максимальное число детей
Person[] children = new Person[Child_Max];
int count_children = 0; //число детей
/// <summary>
/// Метод-свойство
/// </summary>
public int Count_children 
{ get { return count_children; } }
   /// <summary>
/// Индексатор по массиву children
/// </summary>
/// <param name="i">индекс элемента в массиве</param>
/// <returns>элемент с заданным индексом</returns>
public Person this[int i] //индексатор
{
    get
    {
        if (i >= 0  i < count_children) return (children[i]);
        else return (children[0]);
    }
    set
    {
        if (i == count_children  i < Child_Max)
        { children[i] = value; count_children++; }
    }
}

Имя у индексатора this, в квадратных скобках в заголовке перечисляются индексы. В методах get, set, обеспечивающих доступ к массиву children, по которому ведется индексирование, анализируется корректность задания индекса. Закрытое поле count_children, хранящее текущее число детей, доступно только для чтения благодаря добавлению соответствующего метода-свойства. Запись в это поле происходит в методе set индексатора, когда к массиву children добавляется новый элемент.

Протестируем процесс добавления детей персоны и работу индексатора:

/// <summary>
/// Тест индексатора 
/// </summary>
public void TestPersonChildren()
{
    Person pers1, pers2, pers3, pers4;
    pers1 = new Person();
    pers1.Fam = "Петров"; pers1.Age = 42; 
    pers2 = new Person();
    pers2.Fam = pers1.Fam; pers2.Age = 7;
    pers1[pers1.Count_children] = pers2;
    pers3 = new Person();
    pers3.Fam = pers1.Fam + "а"; pers3.Age = 4;
    pers1[pers1.Count_children] = pers3;
    pers4 = new Person();
    pers4.Fam = pers1.Fam; pers4.Age = 2;
    pers1[pers1.Count_children] = pers4;
    ConsolePrintPerson(pers1);
    ConsolePrintPerson(pers1[0]);
    ConsolePrintPerson(pers1[1]);
    ConsolePrintPerson(pers1[2]);
}

Заметьте, индексатор позволяет индексировать объект pers1 по соответствующему полю, в данном случае - по полю children.

Операции

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

Конструкторы класса Person

Для полноты картины добавим в класс Person множество конструкторов класса.

//Конструкторы класса
public Person(){}
public Person( string fam)
{
    this.fam = fam;
}
public Person(string fam, int age)
{
    this.fam = fam; this.age = age;
}
public Person(string fam, int age,
    string health, int zarplata, Status s)
{
    this.fam = fam; this.age = age; status = s;
    this.health = health; salary = zarplata;
}

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

Класс как модуль

В языке C# разрешается объявить класс, который не рассматривается как тип данных и у которого сохраняется единственная роль - роль модуля. Такой класс объявляется с модификатором static. У такого класса могут быть заданы константы, только статические поля и только статические методы. У него нет конструкторов в обычном смысле этого слова, позволяющих создавать объекты - экземпляры класса. Статический класс не может рассматриваться как тип данных.

Утверждение о том, что для статического класса не создаются объекты, требует уточнения. Один объект создается. Более того, этот статический объект создается всегда, создается автоматически, не требуя выполнения операции new, как это делается для динамически создаваемых объектов. Этот объект получает имя, совпадающее с именем класса. Статический объект, рассматриваемый как модуль класса, создается статическим конструктором, который может быть задан явно, но в случае отсутствия явного задания всегда автоматически добавляется к статическому классу. Конструктор этот вызывается неявно, точный момент его вызова не определен, но гарантируется, что он будет вызван еще до того, как над классом будут выполняться какие-либо операции. Статический конструктор работает точно так же, как и обычный конструктор. Полями создаваемого конструктором объекта будут статические поля и константы класса, которые рассматриваются как статические константы, не требующие задания модификатора static. Информация в полях статического объекта независимо от модификатора доступа открыта для всех статических методов класса, а если эти поля объявлены с модификатором public, то поля доступны и клиентам класса. Так, например, константы PI и E из статического класса Math доступны всем клиентам класса Math.

Содержательно, статический класс - это сервисный класс, предоставляющий свои сервисы клиентам класса. Клиенты не создают объекты статического класса, они все работают с одним статическим объектом - модулем, у которого есть полезные для клиентов методы и поля, хранящие общую для всех информацию. Методы класса Math позволяют вычислять математические функции, необходимые всем арифметическим классам, методы класса Convert позволяют осуществлять преобразование одного типа данных в другой, не принадлежат ни одному из этих типов.

Класс со статическими полями и методами

Рассмотрим теперь общую для C# ситуацию, когда класс, представляющий тип данных, объявленный без модификатора static, имеет как обычные, так и статические поля и методы. Такой класс в полной мере играет обе роли типа данных и модуля. Клиент класса, вызвав обычный конструктор класса, может создать объект класса, содержащий набор обычных полей. Используя этот объект, как цель вызова, можно вызвать обычный метод класса, который и будет работать с информацией, хранимой в полях объекта. Но параллельно с этим динамическим процессом создания объектов класса статический конструктор класса, автоматически вызванный, создаст единственный статический объект с именем класса, и этот объект доступен всем клиентам наравне с создаваемыми ими динамическими объектами.

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

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

Напомню, что всякий вызов метода в объектных вычислениях имеет вид x.F(...) ; где x - цель вызова. Обычно целью вызова является динамически созданный объект x, вызывающий обычные методы класса, называемые динамическими или экземплярными методами. В этом случае поля целевого объекта доступны методу и служат глобальным источником информации. Если же необходимо вызвать статический метод (поле), то целью является статический объект, имя которого задается именем класса. Этот объект и его методы доступны и тогда, когда ни один другой динамический объект класса еще не создан.

Проектирование класса Rational

В заключение этой лекции займемся проектированием класса Rational, описывающего известный в математике тип данных - рациональные числа. По ходу проектирования будут вводиться новые детали, связанные с описанием класса. Начнем проектирование, как обычно, с задания тэга summary, описывающего назначение класса, его свойства и поведение. Вот этот текст:

/// <summary>
/// Класс Rational.
/// определяет новый тип данных - рациональные числа и основные
/// операции над ними - сложение, умножение, вычитание и деление.
/// Рациональное число задается парой целых чисел (m,n) и изображается
/// обычно в виде дроби m/n. Число m называется числителем,
/// n - знаменателем. Для каждого рационального числа существует
/// множество его представлений, например, 1/2, 2/4, 3/6, 6/12.
/// Среди всех представлений
/// можно выделить то, в котором числитель и знаменатель взаимно
/// несократимы. Такой представитель будет храниться в полях класса.   
/// </summary>
public class Rational
{
      // Описание тела класса Rational
}//Rational

Свойства класса Rational

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

//Поля класса. Числитель и знаменатель рационального числа.
const string NONE_EXIST =
     "Не существует рационального  числа " +
     "со знаменателем, равным нулю!";      
int m,n;

Конструкторы класса Rational

Зададим два конструктора - конструктор без аргументов, создающий рациональное число 0 и полный конструктор, которому передаются числитель и знаменатель рационального числа. Чуть позже добавим в класс закрытый конструктор и статический конструктор, позволяющий создать константы нашего класса. Вот определение конструкторов:

//Констукторы класса
/// <summary>
/// Конструктор по умолчанию.
/// Создает рациональный 0 - пару (0/1)
/// </summary>
public Rational()
{
    m = 0; n = 1;
}
/// <summary>
/// Конструктор класса. Создает рациональное число
/// m/n, эквивалентное a/b, но с взаимно несократимыми
/// числителем и знаменателем. 
/// Если b = 0, то выбрасывается исключение, 
/// сообщающее о невозможности создать
/// рациональное число со знаменателем 0
/// </summary>
/// <param name="a">числитель</param>
/// <param name="b">знаменатель</param>
public Rational(int a, int b)
{
    if (b == 0) throw new RationalException(NONE_EXIST);
    //приведение знака
    if (b < 0) { b = -b; a = -a; }
    //приведение к несократимой дроби
    int d = Nod(a, b);
    m = a / d; n = b / d;            
}

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

При попытке создать рациональное число со знаменателем 0 выбрасывается исключение, представляющее объект класса RationalException. Это типичная ситуация, когда совместно с проектируемым классом создается и класс исключений, характеризующий исключительные ситуации, которые могут возникнуть при работе клиента с объектами класса. Чуть позже приведу объявление этого класса.

Методы класса Rational

Если поля класса почти всегда закрываются, чтобы скрыть от пользователя представление данных класса, то методы класса всегда имеют открытую часть - те сервисы (службы), которые класс предоставляет своим клиентам и наследникам. Но не все методы открываются. Большая часть методов класса может быть закрытой, скрывая от клиентов детали реализации, необходимые для внутреннего использования. Заметьте, сокрытие представления и реализации делается не по соображениям утаивания того, как реализована система. Чаще всего, ничто не мешает клиентам ознакомиться с полным текстом класса. Сокрытие делается в интересах самих клиентов. При сопровождении программной системы изменения в ней неизбежны. Клиенты не почувствуют на себе негативные последствия изменений, если они делаются в закрытой части класса. Чем больше закрытая часть класса, тем меньше влияние изменений на клиентов класса.

Закрытый метод НОД

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

/// <summary>
/// Закрытый метод класса.
/// Возвращает наибольший общий делитель чисел a,b
/// </summary>
/// <param name="a">первое число</param>
/// <param name="b">второе число</param>
/// <returns>НОД(a,b)</returns>
int Nod(int m, int n)
{
   int p=0;
   m=Math.Abs(m); n =Math.Abs(n);
   do
   {
      p = m%n; m=n; n=p;
   }while (n!=0);
   return(m);
}//Nod

Печать рациональных чисел

Любой класс содержит метод ToString, наследованный от родительского класса object. Переопределим этот метод для класса Rational так, чтобы он задавал строковое представление рационального числа в формате m/n. Тогда печать рациональных чисел ничем не будет отличаться от печати чисел арифметического типа. Вот код метода ToString для класса Rational:

/// <summary>
/// Представление рационального числа 
/// в виде строки
/// </summary>
/// <returns>строка в формате m/n</returns>
public override string ToString()
{
    return m + "/" + n;
}

Тестирование создания рациональных чисел

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

public void TestCreateRational()
{
    try
    {                 
         Rational r1 = new Rational(-5, -25);
         Console.WriteLine("r1 = " + r1.ToString());
         Rational r2 = new Rational();
         Console.WriteLine("r2 = " + r2.ToString());
         Rational r3 = new Rational(4, -8);
         Console.WriteLine("r3 = " + r3.ToString());  
         Rational r4 = new Rational(2, 6); 
         Console.WriteLine("r4 = " + r4.ToString()); 
         Rational r5 = new Rational(0, 0);
         Console.WriteLine("r5 = " + r5.ToString());
    }
    catch (RationalException e)
    {
        Console.WriteLine(e.Message);
    }
}

Вот как выглядят результаты ее работы:

Операции над рациональными числами

Определим над рациональными числами стандартный набор операций - сложение и вычитание, умножение и деление. Реализуем эти операции методами с именами Plus, Minus, Mult, Divide, соответственно. Поскольку рациональные числа - это прежде всего именно числа, то для выполнения операций над ними часто удобнее пользоваться привычными знаками операций ( +, -, *, / ). Язык C# допускает определение операций, заданных указанными символами. Этот процесс называется перегрузкой операций, и мы рассмотрим сейчас, как это делается. Перегрузка операций дает дополнительные преимущества, поскольку автоматически позволяет строить выражения над рациональными числами, используя привычные знаки операций и скобки. При вычислении выражений сохраняются привычные приоритеты операций.

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

Покажем вначале реализацию метода Plus и операции +:

public Rational Plus(Rational a)
{
    int u, v;
    u = m * a.n + n * a.m; v = n * a.n;
    return (new Rational(u, v));
}//Plus
public static Rational operator +(Rational r1, Rational r2)
{
    return (r1.Plus(r2));
}

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

Операция является статическим методом класса с модификатором static. Именем соответствующего метода является сам знак операции, которому предшествует ключевое слово operator. Важно понимать, что метод Plus является динамическим, экземплярным методом класса. Перегруженная операция " + " является статическим методом, частью модуля, связанного с классом Rational.

Аналогичным образом определим остальные операции над рациональными числами:

public Rational Minus(Rational a)
{
   int u,v;
   u = m*a.n - n*a.m; v= n*a.n;
   return( new Rational(u, v));
}//Minus
public static Rational operator -(Rational r1, Rational r2)
{
   return (r1.Minus(r2));
}
public Rational Mult(Rational a)
{
   int u,v;
   u = m*a.m; v= n*a.n;
   return( new Rational(u, v));
}//Mult
public static Rational operator *(Rational r1, Rational r2)
{
   return (r1.Mult(r2));
}
public Rational Divide(Rational a)
{
   int u,v;
   u = m*a.n; v= n*a.m;
   return( new Rational(u, v));
}//Divide
public static Rational operator /(Rational r1, Rational r2)
{
   return (r1.Divide(r2));
}

Вот тест, проверяющий работу этих операций:

public void TestOperRational()
{
    Rational r1 = new Rational(1, 2), r2 = new Rational(1, 3);
    Rational r3, r4, r5, r6;
    r3 = r1 - r2; r4 = r1 * r2; r5 = r1 / r2; 
    r6 = (r3 + r4) * (r5 - r3)/r4;
    Console.WriteLine("r1 = " + r1.ToString());
    Console.WriteLine("r2 = " + r2.ToString());
    Console.WriteLine("r3 = " + r3.ToString());
    Console.WriteLine("r4 = " + r4.ToString());
    Console.WriteLine("r5 = " + r5.ToString());
    Console.WriteLine("r6 = " + r6.ToString());
}

Результаты работы этого теста показаны на рис. 1.2. Обратите внимание: при перегрузке операций и вычислении выражения сохранился общепринятый приоритет операций.

Константы класса Rational

Рассмотрим важную проблему определения констант в собственном классе. Определим две константы 0 и 1 класса Rational. Кажется, что сделать это невозможно из-за ограничений, накладываемых на объявление констант. Напомню, константы должны быть инициализированы в момент объявления и их значения должны быть заданы константными выражениями, известными в момент компиляции. Но в момент компиляции у класса Rational нет никаких известных константных выражений. Как же быть? Справиться с проблемой поможет статический конструктор. Нам также будет полезен закрытый конструктор класса. Роль констант класса будут играть статические поля, объявленные с атрибутом readonly, доступные только для чтения.

//Константы класса 0 и 1 - Zero и One
      public static readonly Rational Zero, One;

А теперь зададим закрытый и статический конструкторы. Статический конструктор будет определять константы класса. Чтобы создать рациональное число, играющее роль константы, статический конструктор вызывает обычный конструктор. Для этого можно было бы воспользоваться имеющимся открытым конструктором, но давайте для полноты картины определим закрытый конструктор.

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

Rational(int a, int b, string t)
{
    m = a; n = b;
}//Закрытый конструктор
static Rational()
{
    Zero = new Rational(0, 1, "");
    One = new Rational(1, 1, "");
}//Статический конструктор

Как это все работает? Статический конструктор вызывается автоматически один раз до начала работы с объектами класса. Он и задаст значения статических полей Zero, One, представляющих рациональные числа с заданным значением. Поскольку эти поля имеют модификатор public static readonly, то они доступны для всех методов класса и для клиентов класса. Они не изменяются в ходе вычислений, являясь настоящими константами класса. Прежде чем привести пример работы с константами, давайте добавим в наш класс важные булевые операции над рациональными числами - равенство и неравенство, больше и меньше. При этом две последние операции сделаем перегруженными, позволяя сравнивать рациональные числа с числами типа double:

public static bool operator ==(Rational r1, Rational r2)
{
    return ((r1.m == r2.m)  (r1.n == r2.n));
}
public static bool operator !=(Rational r1, Rational r2)
{
    return ((r1.m != r2.m) || (r1.n != r2.n));
}        
public static bool operator <(Rational r1, Rational r2)
{
    return (r1.m * r2.n < r2.m * r1.n);
}
public static bool operator >(Rational r1, Rational r2)
{
    return (r1.m * r2.n > r2.m * r1.n);
}
public static bool operator <(Rational r1, double r2)
{
    return ((double)r1.m / (double)r1.n < r2);
}
public static bool operator >(Rational r1, double r2)
{
    return ((double)r1.m / (double)r1.n > r2);
}
public override bool Equals(object obj)
{
    return this == (Rational)obj;
}
public override int GetHashCode()
{
    return m + n;
}

Определив операции сравнения рациональных чисел, логично переопределить и метод Equals, наследуемый от object, а вслед за ним и метод GetHashCode, завершив тем самым определение собственного класса.

Наш последний пример демонстрирует работу с константами, булевыми и арифметическими выражениями над рациональными числами:

public void TestRationalConst()
{
    Rational r1 = new Rational(0, 8), r2 = new Rational(2, 5);
    Rational r3 = new Rational(4, 10), r4 = new Rational(3, 7);
    Rational r5 = Rational.Zero, r6, r7;
    if ((r1 != Rational.Zero)  (r2 == r3)) 
        r6 = (r3 + Rational.One) * r4;
    else r6 = Rational.One + Rational.One;
    if ((r6 > r3)  (r4 > 0.5)) r7 = r1; 
    else r7 = r2;
    Console.WriteLine("r1 = " + r1.ToString());
    Console.WriteLine("r2 = " + r2.ToString());
    Console.WriteLine("r3 = " + r3.ToString());
    Console.WriteLine("r4 = " + r4.ToString());
    Console.WriteLine("r5 = " + r5.ToString());
    Console.WriteLine("r6 = " + r6.ToString());
    Console.WriteLine("r7 = " + r7.ToString());
}

Результаты работы этого примера показаны на рис. 1.3

Класс RationalException

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

Как правило, при проектировании класса параллельно с ним проектируется и класс, задающий исключительные ситуации. Такой класс должен быть объявлен как наследник класса Exception из библиотеки FCL, наследуя тем самым свойства и методы, общие для всех объектов, задающих исключения. Чаще всего, как это имеет быть место и в нашем случае, класс потомок устроен довольно просто и содержит набор конструкторов, вызывающих конструктор родительского класса, передавая ему информацию о возникшей ситуации. Более подробно поговорим об этом в соответствующей лекции, посвященной исключениям, а сейчас приведу код класса RationalException:

/// <summary>
/// Класс, задающий исключения при работе
/// с рациональными числами.
/// </summary>
public class RationalException : Exception
{
    public RationalException() { }
    public RationalException(string message) :
        base(message) { }
    public RationalException(string message,
        Exception e)
        : base(message, e) { }
}

Итоги. Как проектировать класс

Класс Rational является простым, но хорошим примером проектирования класса. Давайте перечислим основные вопросы, которые приходится решать при создании класса.

Архитектура Решения

Как обычно, для демонстрации примеров данной лекции построено Решение с именем главы Ch3_1. В Решение включены три проекта. Проект DLL с именем ClassSamples содержит три класса - Person, Rational и SRational, служащих примерами описания классов и структур. Структура SRational этой DLL используется в проекте, построенном для примеров следующей лекции этого курса. Проект DLL с именем Geometrical_Figures содержит примеры классов, задающих геометрические фигуры и понятия, используемые в вычислительной геометрии. Эта DLL также будет использоваться в примерах, приводимых в последующих лекции курса. Консольный проект ConsoleWithClasses содержит традиционный класс Testing, большое число методов которого представляют собой различные тесты, иллюстрирующие работу с различными объектами классов из DLL, присоединенных к консольному проекту.

Задачи

Трансляция выражений

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

S1 = 2 +3*5/7;
S2 = 2 * sin(x) - (3 + cos(x)) * (x +5);
S3 = (x > y)  (x < 10) || (y > 5).

Рассмотрим классическую схему решения этой задачи. Первым делом производится разбор выражения - лексический анализ, где выражение преобразуется в последовательность лексем. Затем выражение записывается в виде обратной польской записи, а затем уже вычисляется значение преобразованного выражения.

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

Обратная польская запись выражения - это бесскобочная запись, где операции непосредственно предшествуют операнды операции. Наши выражения S1 - S3 в обратной польской записи имеют вид:

CS1 = 2 3 5 * 7 / +;
CS2 = 2 x sin * 3 x cos + x 5 + * -;
CS3 = x y > x 10 <  y 5 > ||;

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

Пока stackExpression не пуст, читается очередная лексема Lex с вершины стека. Затем производится анализ типа этой лексемы и приоритета, если лексема задает операцию. Если лексема - операнд, то она помещается в очередь queueBackExpression. Если лексема - открывающая скобка, то она записывается в очередь queueOperations. Если лексема - закрывающая скобка, то из очереди queueOperations выгружаются все элементы вплоть до открывающей скобки. Эти элементы записываются в выходную очередь queueBackExpression. Знаки скобок в выходной стек не записываются. Если лексема - операция, то анализируется ее приоритет. Если приоритет лексемы выше приоритета последней операции, записанной в queueOperations, то новая операция записывается в очередь queueOperations. В противном случае операция из очереди выгружается и записывается в очередь queueBackExpression. Когда стек stackExpression опустоша ется, то все операции, оставшиеся в очереди queueOperations, выгружаются и записываются в очередь queueBackExpression.

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

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

Задачи на трансляцию выражений

Проекты

Практикум 2. Создание простого приложения в Visual Studio 2010

В практикуме показывается пример создания простой программы в Visual Studio 2010 на языке C#.