Универсальность. Классы с родовыми параметрами

Реализация стека массивом

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

public class ArrayUpStack<T> : GenStack<T>
   {
      int SizeOfStack;
      T[] stack;
      int top;
      /// <summary>
      /// конструктор
      /// </summary>
      /// <param name="size">размер стека</param>
      public ArrayUpStack(int size)
      { SizeOfStack = size; stack = new T[SizeOfStack]; top = 0; }
      /// <summary>
      /// require: (top < SizeOfStack)
      /// </summary>
      /// <param name="x"> элемент, помещаемый в стек</param>
      public override void put(T x)
      { stack[top] = x; top++; }
      
      public override void remove()
      { top--; }      
      public override T item()
      { return (stack[top-1]); }
      public override bool empty()
      { return (top == 0); }
   }//class ArrayUpStack

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

public void TestStacks()
  {
    OneLinkStack<int> stack1 = new OneLinkStack<int>();
    OneLinkStack<string> stack2 = new OneLinkStack<string>();
    ArrayUpStack<double> stack3 = new ArrayUpStack<double>(10);

    stack1.put(11); stack1.put(22);
    int x1 = stack1.item(), x2 = stack1.item();
    if ((x1 == x2) && (x1 == 22)) Console.WriteLine("OK!");   
    stack1.remove(); x2 = stack1.item();
    if ((x1 != x2) && (x2 == 11)) Console.WriteLine("OK!");
    stack1.remove(); x2 = (stack1.empty())? 77 : stack1.item();
    if ((x1 != x2) && (x2 == 77)) Console.WriteLine("OK!");

    stack2.put("first"); stack2.put("second");
    stack2.remove(); string s = stack2.item();
    if (!stack2.empty()) Console.WriteLine(s);

    stack3.put(3.33); stack3.put(Math.Sqrt(Math.PI));
    double res = stack3.item();
    stack3.remove(); res += stack3.item();
    Console.WriteLine("res= {0}", res);
  }

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

Рис. 8.2. Три стека, порожденных универсальным классом

Дополним наше рассмотрение еще одним примером работы с вариацией стеков, в том числе - хранящим объекты класса Person:

public void TestPerson()
 {
    OneLinkStack<int> stack1 = new OneLinkStack<int>();
    OneLinkStack<string> stack2 = new OneLinkStack<string>();
    ArrayUpStack<double> stack3 = new ArrayUpStack<double>(10);
    ArrayUpStack<Person> stack4 = new ArrayUpStack<Person>(7);

    stack2.put("Петров"); stack2.put("Васильев"); stack2.put("Шустов");
    stack1.put(27); stack1.put(45); stack1.put(53);
    stack3.put(21550.5); stack3.put(12345.7); stack3.put(32458.8);

    stack4.put(new Person(stack2.item(), stack1.item(), stack3.item()));
    stack1.remove(); stack2.remove(); stack3.remove();
    stack4.put(new Person(stack2.item(), stack1.item(), stack3.item()));
    stack1.remove(); stack2.remove(); stack3.remove();
    stack4.put(new Person(stack2.item(), stack1.item(), stack3.item()));

    Person pers = stack4.item(); pers.PrintPerson();
    stack4.remove(); pers = stack4.item(); pers.PrintPerson();
    stack4.remove(); pers = stack4.item(); pers.PrintPerson();
    stack4.remove(); if (stack4.empty()) Console.WriteLine("OK!");
 }

Результаты работы этой процедуры приведены на рис. 8.3.

Рис. 8.3. Работа со стеком Person

Ограниченная универсальность

Хорошо, когда есть свобода. Еще лучше, когда свобода ограничена. Аналогичная ситуация существует и с универсальностью. Универсальность следует ограничивать. На типы универсального класса, являющиеся его параметрами, следует накладывать ограничения. Звучит парадоксально, но, наложив ограничения на типы, программист получает гораздо большую свободу в работе с объектами этих типов.

Если немного подумать, то это совершенно естественная ситуация. Когда имеется неограниченная универсальность, над объектами типов можно выполнять только те операции, которые допускают все типы, - в C# это эквивалентно операциям, разрешенным над объектами типа object, прародителя всех типов. В нашем предыдущем примере, где речь шла о свопинге, над объектами выполнялась единственная операция присваивания. Поскольку присваивание внутри одного типа разрешено для всех типов, неограниченная универсальность приемлема в такой ситуации. Но что произойдет, если попытаться выполнить сложение элементов, сравнение их или даже простую проверку элементов на равенство? Немедленно возникнет ошибка еще на этапе компиляции. Эти операции не разрешены для всех типов, поэтому в случае компиляции такого проекта ошибка могла бы возникнуть на этапе выполнения, когда вместо формального типа появился бы тип конкретный, не допускающий подобную операцию. Нельзя ради универсальности пожертвовать одним из важнейших механизмов C# и Framework .Net - безопасностью типов, поддерживаемой статическим контролем типов. Именно поэтому неограниченная универсальность существенно ограничена. Ее ограничивает статический контроль типов. Бывают, разумеется, ситуации, когда необходимо на типы наложить ограничения, позволяющие ослабить границы статического контроля, что, повторяю, дает большую свободу программисту.

В языке C# допускаются три вида ограничений накладываемых на родовые параметры.

• Ограничение наследования. Это основный вид ограничений, указывающий, что тип T является наследником некоторого класса и ряда интерфейсов. Следовательно, над объектами типа T можно выполнять все операции, заданные базовым классом и интерфейсами. Эти операции статический контроль типов будет допускать, и обеспечивать для них интеллектуальную поддержку, показывая список разрешенных операций. Ограничение наследования позволяет выполнять над объектами больше операций, чем в случае неограниченной универсальности. Синтаксически ограничение выглядит так: where T: BaseClass, I1, …Ik.
• Ограничение конструктора.Это ограничение указывает, что тип T имеет конструктор без аргументов и, следовательно, позволяет создавать объекты типа T. Синтаксически ограничение выглядит так: where T: new().
• Ограничение value/reference. Это ограничение указывает, к значимым или к ссылочным типам относится тип T. Для указания значимого типа задается слово struct, для ссылочных - class. Так что синтаксически этот тип ограничений выглядит так: where T: struct.

Возникает законный вопрос: насколько полна предлагаемая система ограничений? Конечно, речь идет о практической полноте, а не о математически строгих определениях. С позиций практики систему хотелось бы дополнить, в первую очередь, введением ограничений операций, указывающим допустимые знаки операций в выражениях над объектами соответствующего типа. Хотелось бы, например, указать, что к объектам типа T применима операция сложения + или операция сравнения <. Позже я покажу, как можно справиться с этой проблемой, но предлагаемое решение довольно сложно. Наличие ограничения, допускающего операции, намного элегантнее решало бы эту проблему.

Синтаксис ограничений

Уточним некоторые синтаксические правила записи ограничений. Если задан универсальный класс с типовыми параметрами T1, … Tn, то на каждый параметр могут быть наложены ограничения всех типов. Ограничения задаются предложением where, начинающегося соответствующим ключевым словом, после которого следует имя параметра, а затем через двоеточие - ограничения первого, второго или третьего типа, разделенные запятыми. Порядок их важен: если присутствует ограничение третьего типа, то оно записывается первым. Заметьте, предложения where для разных параметров отделяются лишь пробелами; как правило, они записываются на отдельных строчках. Предложения where записываются в конце заголовка класса после имени и списка его типовых параметров, после родительских классов и интерфейсов, если они заданы для универсального класса. Вот синтаксически корректные объявления классов с ограничением универсальности:

public class Father<T1, T2>
   { }
   public class Base
   {
      public void M1() { }
      public void M2() { }
   }
   public class Child<T1,T2> :Father<T1,T2>
      where T1:Base,IEnumerable<T1>, new()
      where T2:struct,IComparable<T2>
   {   }

Универсальный класс Child задан с ограничениями на родовые параметры. Благодаря этому для данных типа T1 можно вызывать методы M1 и M2 базового класса Base, так же как и методы интерфейса IEnumerable<T1>. Можно создавать объекты типа T1, используя конструктор по умолчанию. Фактический тип, подставляемый вместо формального типа T2, должен быть значимым, и объекты этого типа разрешается сравнивать между собой.