Как составить иерархию классов

Как работать с иерархической структурой классов

Задача классификации — одна из самых известных в машинном обучении. Очень многие проблемы, решаемые с помощью ML, так или иначе сводятся к классификации — распознавание изображений, например. И все выглядит просто и понятно, когда нам нужно определить объект в один из нескольких классов. А что если у нас не плоская структура из нескольких классов, а сложная разветвленная иерархия на 683 категории? Именно о таком случае мы сегодня и поговорим. Под катом — рассказ о том, зачем в задачах классификации нужны сложные иерархии и как с ними жить.

В любой задаче классификации есть набор классов и есть модель, которая умеет предсказывать класс для новых данных. Допустим, модель бинарной классификации Спам/не спам, модель классификации настроения текста Хорошо/нейтрально/плохо. Классы обычно являются абстракцией реальности, а абстракция — это всегда упрощение. 

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

Это звучит понятно в школьном учебнике, но в контексте машинного обучения возникает множество вопросов: 

• Как с этим всем обращаться? 

• Какие классы предсказывать? 

• Сколько моделей тренировать для решения задачи? 

• Как работать с данными? 

• Как вносить изменения в иерархию классов и как реагировать на эти изменения с точки зрения модели?

Все эти проблемы мы разберем на примере задачи классификации, которую мы решаем в Контуре.

Постановка задачи

Мы работаем с чеками. В каждом чеке может встретиться много разных товаров, которые можно сгруппировать множеством разных способов. На данный момент нам интересно группировать эти товары с помощью дерева категорий, которое мы будем называть KPC (Khajiit Product Classification). Это здоровенное дерево, состоящее из 683 категорий.

Для этих категорий у нас есть Golden Set, наш размеченный набор данных (штрихкод — категория KPC) для обучения. В датасете почти три миллиона записей и мы постоянно работаем над его дополнением и улучшением разметки.

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

Давайте разберемся, как выглядят разные этапы классификации с иерархической структурой классов.

Разметка данных

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

Так появились статусы категорий. Они помогают понять, в каком состоянии категория прямо сейчас. Благодаря статусам мы можем отдельно обрабатывать только что появившиеся категории или категории, которые скоро будут удалены. На текущий момент мы выделяем четыре статуса категорий:

• Активный.

• Запланированный — категория, на которую мы хотим классифицировать, но пока не можем (не хватает данных или не почистили разметку).

• Архивный — категория, которую решено было удалить, но товары из категории еще не переразметили.

• Удаленный.

В зависимости от статуса мы решаем, что делать с конкретной категорией на каждом из этапов классификации.  

Также стоит упомянуть две отдельные группы категорий:

• «свалка» (например «Одежда (свалка)») — группа для логического удаления некоторых товаров, которые невозможно категоризировать. Например, у нас есть товар «Полное тестирование Тест 2 10шт», у которого из какого-то источника данных стоит категория Одежда. Наш аналитик данных понимает, что по факту категории у такого товара нет, поэтому такой товар отправляется в свалку, которая при обучении не рассматривается.

• «другое/другие» (например «Молочные товары, сыры и яйцо (другое)») — группа для товаров, которые относятся к родительской категории, но не относятся (возможно, пока) ни к одной из дочерних.

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

Добавление категории

Добавить категорию мы можем в любое время, но для того, чтобы товары начали в неё попадать, необходимо:

• Добавить категорию в KPC.

• Переразметить обучающую выборку в соответствии с новой категорией (если товары новой категории раньше относились к другой категории — проверить, что теперь они относятся к правильной).

• Переобучить модель, чтобы она научилась классифицировать товары в новую категорию.

Удаление категории

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

Для удаления категории необходимо:

• Перевести категорию в статус Архивная.

• Решить, что мы делаем с товарами, которые относились к удаляемой и дочерним категориям.

• Заменить удаляемую категорию у товаров в Golden Set.

• Указать дочерним категориям новую родительскую категорию или её отсутствие (если дочерняя категория должна стать категорией верхнего уровня).

• Переобучить модель, чтобы она перестала классифицировать товары в удаляемую категорию (и начала классифицировать эти товары в новые категории).

• Перевести категорию в статус Удаленная.

Разбиение категории

Если появляется необходимость разбить одну категорию на несколько новых, нужно:

• Обновить категории в Golden Set, чтобы отнести товары к новым категориям.

• Переобучить модель, чтобы она научилась классифицировать товары в новые категории.

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

Обучение модели

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

Такие коллизии плохо влияют на обучение — товар может одновременно оказаться в обеих категориях и это может смутить нашу модель. Чтобы избежать таких случаев, перед обучением добавлен этап разрешения конфликтов дерева категорий (KPC collisions resolving).

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

Алгоритм разрешения конфликтов

Для начала разберемся с тем, что такое конфликт или коллизия. Коллизией мы считаем ситуацию, когда пара категорий ребенок/родитель одновременно представлена в KPC. То есть часть товаров размечена родительской категорией, часть — дочерней. Как уже упоминалось выше, такие ситуации плохо влияют на обучение.

Для разрешения этих ситуаций мы будем маппить категории (то есть переносить все товары из одной категории в другую), а после обновлять наше дерево категорий (оставлять в рассмотрении только те категории, которые представлены в Golden set), проверяя, остались ли коллизии.

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

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

Future/Active на схеме — это статусы категорий Запланированная/Активная, а present/NOT present in GS — представлена ли категория в Golden set.

Еще один вопрос, который важно разобрать — что мы хотим делать с Запланированными категориями? И что мы хотим делать с их детьми?

Есть несколько вариантов. Мы можем:

• Использовать эти категории в классификации.

• Не классифицировать и выбросить категории из GS.

• Переразмечать эти категории в категорию-родителя.

• Переразмечать эти товары в категорию «другое/другие» (например «Молочные продукты, сыры и яйцо (другое)»)

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

1. Убрать удаленные, редко встречающиеся (меньше 10 товаров в golden set) и те категории, у которых в названии есть «свалка».

2. Если все дети категории в статусе «Запланированный», то  дочерние категории маппятся в родителя. Это происходит итеративно, так как после первого маппинга может возникнуть аналогичная ситуация на другом уровне дерева.

3. Смаппить запланированные категории в sibling-категорию с «другое/другие» в названии, если такая есть.

4. Удалить из Golden Set категории, у которых есть категории-потомки с товарами в Golden Set. Здесь происходит то самое разрешение конфликтов.

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

Валидация модели

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

В первую очередь мы сравниваем базовые метрики — accuracy (по всем классам) и accuracy/coverage. Необходимо следить за тем, чтобы баланс покрытия и точности не нарушался, а также за возможностью подобрать threshold для новой модели, при котором этот баланс соответствует нашим требованиям.

Во вторую очередь будем смотреть на метрики отдельно по каждому классу. Сначала на те, с которыми модель непосредственно знакома. Затем на родительские классы, путем агрегации (взвешенное среднее).

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

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

'errors' - sum of errors of confusing two labels,
'label_1_confuse' - count(true=label_1, pred=label_2) / 'errors',
'label_2_confuse' - count(true=label_2, pred=label_1) / 'errors',
'fraction_of_error_to_label_1' - count(true=label_1, pred=label_2) / total_label_1,
'fraction_of_error_to_label_2' - count(true=label_2, pred=label_1) / total_label_2,
'fraction_of_all_errors' - 'errors' / total_errors,
'fraction_of_all_errors_cumulative'

Выводы

1. Для удобной итеративной работы с деревом категорий полезно ввести статусы категорий. Такие статусы позволят обрабатывать категории в разном состоянии разными способами.

2. При валидации стоит агрегировать метрики для родительских категорий, чтобы иметь возможность сравнить две модели с разными наборами классов.

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

14.1 Иерархия

Управлять большим количеством разрозненных классов довольно сложно. С этой проблемой можно справиться путем упорядочивания и ранжирования классов, то есть объединяя общие для нескольких классов свойства в одном классе и используя его в качестве базового. Эту возможность предоставляет механизм наследования.

Наследование применяется для следующих взаимосвязанных целей:

1. исключения из программы повторяющихся фрагментов кода;
2. упрощения модификации программы;
3. упрощения создания новых программ на основе существующих.

Наследование является единственной возможностью использовать объекты, исходный код которых недоступен, но в которые требуется внести изменения.

Кроме механизма наследования в данном разделе мы рассмотрим такие важные понятия ООП как полиморфизм и инкапсуляцию (см.
«Технология объектно-ориентированного программирования»
), которые также принимают участие в формировании иерархии классов.

Наследование

Класс в С# может иметь произвольное количество потомков и только одного предка. При описании класса имя его предка записывается в заголовке класса после двоеточия. Если имя предка не указано, предком считается базовый класс всей иерархии System.Object. Синтаксис наследования:

[атрибуты] [спецификаторы] class имя_класса [: предки]
{ тело_класса}

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

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

Рассмотрим наследование классов на примере геометрических фигур на плоскости. В качестве базового класса создадим класс DemoPoint (точка на плоскости), в качестве производного класса от DemoPoint класс DemoLine (отрезок на плоскости):

class DemoPoint //базовый класс
  {
    public int x;
    public int y;
    public void Show()
    {
      Console.WriteLine("({0}, {1})", x, y);
    }
  }

  class DemoLine : DemoPoint //производный класс
  {
    public int xEnd;
    public int yEnd;
    public  void Show()
    {
      Console.WriteLine("({0}, {1})-({2}, {3})", x, y ,xEnd, yEnd);
    }
  }

  class Program
  {
    static void Main()
    {
      DemoPoint point = new DemoPoint();
      point.x = 0;
      point.y = 0;
      point.Show();
      DemoLine line = new DemoLine();
      line.x = 2;  line.y = 2;
      line.xEnd = 10;  line.yEnd = 10;
      line.Show();
    }
  }

Экземпляр класса DemoLine с одинаковой легкостью использует как собственные поля и методы, так и унаследованные от класса DemoPoint. При этом, если метод производного класса называется также как и метод базового класса, то вызывается метод производного. Однако компилятором будет сгенерировано предупреждение:

Чтобы избежать подобного предупреждения необходимо перед одноименным членом производного класса, в данном случае перед методом Show в классе DemoLine, поставить спецификатор new. Данный спецификатор скрывает одноименный член базового класса и предупреждений выдаваться не будет.

Использование защищенного доступа

В нашем примере поля x и у базового класса были открыты для доступа ( public ). Если убрать public, то поля автоматически станут закрытыми для доступа ( private ), в том числе и для доступа из производного класса. Решить проблему доступа к закрытым полям базового класса из производного можно двумя способами: используя свойства класса или спецификатор protected. При объявлении какого-то члена класса с помощью спецификатора protected, он становится закрытым для всех классов, кроме производных.

class DemoPoint
  {
      protected int x;
      protected int y;
      public void Show()
      {
        Console.WriteLine("({0}, {1})",x, y);
      }
    }

    class DemoLine : DemoPoint
    {
      public int xEnd;
      public int yEnd;
      public new void Show()
      {
        x=2; y=2; //доступ к закрытым полям базового класса
        Console.WriteLine("({0}, {1})-({2}, {3})", x, y, xEnd, yEnd);
      }
    }
   
    class Program
    {
      static void Main()
      {
        DemoPoint point = new DemoPoint();
        point.Show();
        DemoLine line = new DemoLine();
        //line.x = 2; line.y = 2; //доступ к полям закрыт
        line.xEnd = 10;    line.yEnd = 10;
        line.Show();
      }
    }
  }

Обратите внимание на то, что доступ к полям х и y из класса Program невозможен, а из производного класса DemoLine возможен.

Наследование конструкторов

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

В предыдущем примере классы создавались за счет автоматического вызова средствами С# конструктора по умолчанию. Добавим конструктор только в производный класс DemoLine:

class DemoPoint
{
  protected int x;
  protected int y;
  public void Show()
  {
    Console.WriteLine("({0}, {1})",x, y);
  }
}

class DemoLine : DemoPoint
{
  public int xEnd;
  public int yEnd;
  new public void Show()
  {
    Console.WriteLine("({0}, {1})-({2}, {3})", x, y, xEnd, yEnd);
  }

  public DemoLine(int x1, int y1, int x2, int y2) //конструктор производного класса
  {
    x = x1;    y = y1;
    xEnd = x2; yEnd = y2;
  }
}

class Program
{
  static void Main()
  {
    DemoPoint point = new DemoPoint(); //вызывается конструктор по умолчанию 
    point.Show();
    DemoLine line = new DemoLine(2, 2, 10, 10); //вызывается собственный конструктор 
    line.Show();
  }
}

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

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

1. позволяет вызвать конструктор базового класса:

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

   конструктор_производного_класса (список_параметров) : base (список_аргументов)
   { тело конструктора }
   
   где с помощью элемента списка аргументов передаются параметры конструктору базового класса. Например: 
   
   class DemoPoint
       {
         protected int x;
         protected int y;
         public void Show()
         {
           Console.WriteLine("({0}, {1})",x, y);
   }
         public DemoPoint (int x, int y)//конструктор базового класса
         {
           this.x=x;  this.y=y;
         }
       }
   
   class DemoLine : DemoPoint
       {
         public int xEnd;
         public int yEnd;
         new public void Show()
         {
           Console.WriteLine("({0}, {1})-({2}, {3})", x, y, xEnd, yEnd);
         }
   
         public DemoLine(int x1, int y1, int x2, int y2):base(x1, y1) //конструктор производного класса
         {
           xEnd = x2; yEnd = y2;
         }
       }
   
   class Program
       {
         static void Main()
         {
           DemoPoint point= new DemoPoint(5, 5);
           point.Show();
           DemoLine line = new DemoLine( 2, 2, 10, 10);
           line.Show();
         }
       }

   Задание. Объясните, почему в конструкторе базового класса для инициализации полей используется параметр this, а в конструкторе производного класса нет.

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

   class DemoPoint
   {
     protected int x;
     protected int y;
     public void Show()
     {
       Console.WriteLine("({0}, {1})",x, y);
   }
     public DemoPoint () //конструктор базового класса по умолчанию
     {
       this.x=1;  this.y=1;
     }
     public DemoPoint (int x, int y) //конструктор базового класса с параметрами
     {
       this.x=x;  this.y=y;
     }
   }
   
   class DemoLine : DemoPoint
   {
     public int xEnd;
     public int yEnd;
     new public void Show()
     {
       Console.WriteLine("({0}, {1})-({2}, {3})", x, y, xEnd, yEnd);
     }
     public DemoLine() //конструктор производного класса по умолчанию
     {
       xEnd = 100; yEnd = 100;
     }
     public DemoLine(int x2, int y2) //конструктор производного класса с двумя параметрами
     {
       xEnd = x2; yEnd = y2;
     }  
     //конструктор производного класса с четырьмя параметрами
     public DemoLine(int x1, int y1, int x2, int y2):base(x1, y1)
     {
       xEnd = x2; yEnd = y2;
     }
   }
   
   class Program
   {
     static void Main()
     {
       DemoPoint point1= new DemoPoint(); //вызов конструктора по умолчанию
       DemoPoint point2= new DemoPoint(5, 5); //вызов конструктора с параметрами
       point1.Show();
       point2.Show();
       DemoLine line1 = new DemoLine();//вызов конструктора по умолчанию
       DemoLine line2 = new DemoLine(4, 4);   //вызов конструктора с двумя параметрами
       //вызов конструктора с четырьмя параметрами
       DemoLine line3 = new DemoLine(2, 2, 10, 10);
       line1.Show();
       line2.Show();
       line3.Show();
     }
   }

   Задание. Объясните, как при вызове конструкторе производного класса инициируется вызов конструктора базового класса.

2. позволяет получить доступ к члену базового класса, который скрыт «за» членом производного класса.

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

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

   class DemoPoint
     {
       protected int x;
       protected int y;
       public void Show()
       {
         Console.Write("({0}, {1})",x, y);
       }
       public DemoPoint (int x, int y)//конструктор базового класса
       {
         this.x=x;  this.y=y;
       }
     }
   
     class DemoLine : DemoPoint
     {
       public int xEnd;
       public int yEnd;
       new public void Show()
       {
         base.Show(); //вызов члена базового класса
         Console.WriteLine("-({0}, {1})", xEnd, yEnd);
       }
   
       public DemoLine(int x1, int y1, int x2, int y2):base(x1, y1) //конструктор производного класса
       {
         xEnd = x2; yEnd = y2;
       }
     }
   
     class Program
     {
       static void Main()
       {
         DemoLine line = new DemoLine( 2, 2, 10, 10);
         line.Show();
       }
     }

   Несмотря на то, что метод Show в классе DemoLine скрывает одноименный метод в классе DemoPoint, ссылка base позволяет получить доступ к методу Show в базовом классе. Аналогично с помощью ссылки base можно получить доступ к одноименным полям базового класса.

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

При
использовании наследования в C++ для
порождения одного класса из другого
возможны ситуации, когда вы порождаете
свой класс из класса, который уже, в свою
очередь, является производным от
некоторого базового класса. Например,
предположим, вам необходимо использовать
класс сотputer базовый для порождения
класса workstation, как показано ниже:

class
work_station : public computer

{ 

public: 

   work_station
(char *operating_system, char *name, int hard_disk, float
floppy, char *screen, long colors, int x_res, int
      y_res, int processor, int
speed, int RAM); 

   void
show_work_station(void); 

private: 

   char
operating_system[64]; 

};

Конструктор
класса workstation просто вызывает конструктор
класса computer, который в свою очередь
вызывает конструкторы классов
сотрuter_screen и mother_board:

work_station::work_station(
char *operating_system, char *name, int hard_disk, float floppy, char
*screen, long colors, int    x_res, int y_res, int
processor, int speed, int RAM) : computer (name, hard_disk,
floppy, screen, colors, x_res, y_res,    processor,
speed, RAM)

{ 

   strcpy(work_station::operating_system,
operating_system); 

}

В
данном случае класс computer выступает в
роли базового класса. Однако вы знаете,
что класс computer был порожден из классов
computer_screen и mother_board. В результате класс
work_station наследует характеристики всех
трех классов. На рис. 27 показано, что
порождение классов приводит к иерархии
классов.

Рис.
27. Построение иерархии классов.

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

Что вам необходимо знать

Множественное
наследование представляет собой
возможность порождать класс из нескольких
базовых классов. При использовании
множественного наследования производный
класс получает характеристики (элементы)
существующих базовых классов. Поддержка
множественного наследования в C++
предоставляет вашим программам огромные
возможности объектно-ориентированного
программирования. Из урока 28 вы узнаете,
как обеспечить доступ к частным элементам
класса со стороны других классов или
функций других классов, которые вы
указываете как друзей. Используя таких
друзей, вы можете предоставить определенным
функциям прямой доступ к элементам
класса, одновременно обеспечивая их
защиту от остальной части программы.
Прежде чем перейти к уроку 28, убедитесь,
что вы изучили следующее:

1. Множественное
   наследование является способностью
   порожденного класса наследовать
   характеристики нескольких базовых
   классов.

2. Для
   порождения класса из нескольких базовых
   после имени нового класса и двоеточия
   вы указываете имена базовых классов,
   разделяя их запятыми, например class
   cabbit: public cat, public rabbit.

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

4. При
   порождении классов может случиться
   так, что используемый вами базовый
   класс реально порожден из других
   базовых классов. Если так, то ваша
   программа создает иерархию классов.
   Если вызывается конструктор вашего
   производного класса, то вызываются
   также и конструкторы наследуемых
   классов (последовательно).

УРОК
28. ЧАСТНЫЕ ЭЛЕМЕНТЫ И ДРУЗЬЯ

Как
вы уже знаете, ваши программы могут
обращаться к частным (private) элементам
класса только с помощью функций-элементов
этого же класса. Используя частные
элементы класса вместо общих во всех
ситуациях, где это только возможно, вы
уменьшаете возможность программы
испортить значения элементов класса,
так как программа может обращаться
к таким элементам только через интерфейсные
функции (которые управляют доступом к
частным элементам). Однако в зависимости
от использования объектов вашей
программы, иногда вы можете существенно
увеличить производительность позволяя
одному классу напрямую обращаться к
частным элементам другого. В этом случае
уменьшаются издержки (требуемое время
выполнения) на вызов интерфейсных
функций. В подобных ситуациях C++ позволяет
определить класс в качестве друга
(friend} другого класса и разрешает
классу-другу доступ к частным элементам
этого другого класса. В этом уроке
объясняется, как ваши программы могут
указать, что два класса являются друзьями.
К концу данного урока вы освоите следующие
основные концепции:

• Используя
  ключевое слово friend, класс может сообщить
  C++, кто является его другом, т. е. другими
  словами, что другие классы могут
  обращаться напрямую к его частным
  элементам.

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

• C++
  позволяет ограничить дружественный
  доступ определенным набором функций.

Частные
(private) элементы позволяют вам защищать
классы и уменьшить вероятность ошибок.
Таким образом, вы должны ограничить
использование классов-друзей настолько,
насколько это возможно. Иногда программа
напрямую может изменить значения
элементов класса, это увеличивает
вероятность появления ошибок.

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #