«Как функции, не являющиеся методами, улучшают инкапсуляцию»

Скотт Мейерс Как функции, не являющиеся методами, улучшают инкапсуляцию

Предпосылка

Когда, в 1991 г., я писал первое издание "Эффективное использование C++" (Effective C++ [1]), я изучал проблему определения функций, связанных с классом. Для заданного класса C и функции f, связанной с C, я разработал следующий алгоритм:

if (f необходимо быть виртуальной) сделайте f функцией-членом C;

else

 if (f – это operator›› или operator‹‹) {

  сделайте f функцией – не членом;

  if (f необходим доступ к непубличным членам C) сделайте f другом C;

 }

 else if (в f надо преобразовывать тип его крайнего левого аргумента) {

  сделайте f функцией – не членом;

  if (f необходимо иметь доступ к непубличным членам C) сделайте f другом C;

 } else сделайте f функцией-членом C;

Этот алгоритм хорошо служил мне многие годы, и когда я правил "Эффективное использование C++" для второй издания в 1997 г. [2], я не сделал никаких изменений в этот алгоритм.

Однако, в 1998 году, когда я проводил презентацию в Actel, где Аран Канду (Arun Kundu) заметил, что мой алгоритм диктовал, что функции должны быть методами даже тогда, когда они могли бы быть реализованы как не члены, которые использовали только открытый интерфейс класса C. "Это действительно, что-нибудь означает?" – спросил он меня? Другими словами, если f могла бы быть реализован как функция-член (метод) или как функция не являющаяся не другом, не членом, я действительно защищал, что ее надо реализовать как метод класса? Я немного подумал об этом и решил, что это не то, то, что я подразумевал. Поэтому я изменил алгоритм [3]:

if (f необходимо быть виртуальной) сделайте f функцией-членом C;

else if (f – это operator›› или operator‹‹) {

 сделайте f функцией – не членом;

 if (f необходим доступ к непубличным членам C) сделайте f другом C;

} else if (f необходимо преобразовывать тип его крайнего левого аргумента) {

 сделайте f функцией – не членом;

 if (f необходимо иметь доступ к непубличным членам C) сделайте f другом C;

} else if (f может быть реализована через доступный интерфейс класса) сделайте f функцией – не членом;

else сделайте f функцией-членом C;

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

Но они ошибаются.

Инкапсуляция

Инкапсуляция не определяет вершину мира. Нет ничего такого, что могло бы возвысить инкапсуляцию. Она полезна только потому, что влияет на другие аспекты нашей программы, о которых мы заботимся. В частности, она обеспечивает гибкость программы и ее устойчивость к ошибкам. Посмотрите на эту структуру, чья реализация (я думаю, что мы все согласимся) не является инкапсулированной:

struct Point {

 int x, y;

};

Слабостью этой структуры является то, что она не обладает гибкостью при ее изменении. Как только клиенты начнут использовать эту структуру, будет очень тяжело изменить ее. Придется изменять слишком много клиентского кода. Если бы мы позднее решили, что хотели бы вычислять x и y вместо того, чтобы хранить эти значения, мы были бы обречены на неудачу. У нас возникли бы аналогичные проблемы при запоздалом озарении, что программа должна хранить x и y в базе данных. Это реальная проблема при недостаточной инкапсуляции: имеется препятствие для будущих изменений реализации. Неинкапсулированное программное обеспечение негибко, и, в результате, оно не очень устойчиво. При изменении внешних условий программное обеспечение неспособно элегантно измениться вместе с ними. Не забывайте, что мы говорим здесь о практической стороне, а не о том, что является потенциально возможным. Понятно, что можно изменить структуру Point. Но, если большой объем кода зависит от этой структуры, то такие изменения не являются практичными.

Перейдем к рассмотрению класса с интерфейсом, предлагающим клиентам возможности, подобные тем, которые предоставляет выше описанная структура, но с инкапсулированной реализацией:

class Point {

public:

 int getXValue() const;

 int getYValue() const;

 void setXValue(int newXValue);

 void setYValue(int newYValue);

private:

… // прочее…

};

Этот интерфейс поддерживает реализацию, используемую структурой (сохраняющей x и y как целые), но он также предоставляет альтернативные реализации, основанные, например, на вычислении или просмотре базы данных. Это более гибкий замысел, и гибкость делает возникающее в результате программное обеспечение более устойчивым. Если реализация класса найдена недостаточной, она может быть изменена без изменения клиентского кода. Принятые объявления доступных методов остаются, неизменными, что ведет к неизменности клиентского исходного текста. (Если необходимые провести изменения [4], то клиенты не нуждаются даже в перетрансляции.)

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

Степень инкапсуляции

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

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

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

Инкапсуляция и функции – не члены

Мы теперь видим, что приемлемый способом оценки инкапсуляции является количество функций, которые могли бы быть разрушены, если изменяется реализация класса. В этом случае становится ясно, что класс с n методами более инкапсулирован, чем класс с n+1 методами. И это наблюдение поясняет мое предпочтение в выборе функций, не являющихся ни друзьями, ни методами: если функция f может быть выполнена как метод или как функция, не являющаяся другом, то создание ее в виде метода уменьшило бы инкапсуляцию, тогда как создание ее в виде "недруга" инкапсуляцию не уменьшит. Так как функциональность здесь не обсуждается (функциональные возможности f доступны классам клиентов независимо от того, где эта f размещена), мы естественно предпочитаем более инкапсулированный проект.

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

Этот анализ применяется к любому виду методов, включая и статические. Добавление статического метода к классу, когда его функциональные возможности могут быть реализованы как не члены и не друзья уменьшают инкапсуляцию точно так же, как это делает добавление нестатического метода. Перемещение свободной функции в класс с оформлением ее в виде статического метода, только для того, чтобы показать, что она соприкасается с этим классом, является плохой идеей. Например, если я имею абстрактный класс для виджетов (Widgets) и затем использую функцию фабрики классов [4,5,6], чтобы дать возможность клиентам создавать виджеты, я могу использовать следующий общий, но худший способ организовать это:

// a design less encapsulated than it could be

class Widget {

 … // внутренее наполнение Widget; может быть:

 // public, private, или protected

public:

 // может быть также "недругом" и не членом

 static Widget* make(/* params */);

};

Лучшей идеей является создание вне Widget, что увеличивает совокупную инкапсуляцию системы. Чтобы показать, что Widget и его создание (make) все-таки связаны, используется соответствующее пространство имен (namespace):

// более инкапсулированный проект

namespace WidgetStuff {

 class Widget {…};

 Widget* make(/* params */);

};

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

Синтаксические проблемы

Возможно что Вы, как и многие люди, с которыми я обсуждал эту проблему, имеете представление относительно синтаксического смысла моего утверждения, что не методы и не друзья предпочтительнее методов. Возможно, что Вы даже "купились" на мои аргументы относительно инкапсуляции. Теперь, предположим, что класс Wombat (Вомбаты – семейство австралийских млекопитающих отряда сумчатых. Благодарю Алекса за коррекцию перевода. А.Л.) поддерживает функциональные возможности, поедания и засыпания. Далее предположим, что функциональные возможности, связанные с поеданием, должны быть выполнены как метод, а засыпание может быть выполнено как член или как не член и не друг. Если Вы следуете моим советам, описанным выше, вы создадите описание подобные этим:

class Wombat {

public:

 void eat(double tonsToEat);

 …

};

void sleep(Wombat& w, double hoursToSnooze);

Это привело бы к синтаксическому противоречию для клиентов класса, потому что для

Wombat w;

они напишут:

w.eat(.564);

при вызове eat. Но они написали бы:

sleep(w, 2.57);

для выполнения sleep. При использовании только методов класса можно было бы иметь более опрятный код:

class Wombat {

public:

 void eat(double tonsToEat);

 void sleep(double hoursToSnooze);

 …

};

w.eat(.564);

w.sleep(2.57);

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

Чтобы непосредственно ее использовать, нужны функции – не методы. Позвольте нам продолжить пример Wombat. Предположим, что Вы пишете программу моделирования этих прожорливых созданий, и воображаете, что одним из методов, в котором Вы часто нуждаетесь при использовании вомбатов, является засыпание на полчаса. Ясно, что Вы можете засорить ваш код обращениями w.sleep (.5), но этих (.5) будет так много, что их будет трудно напечатать. А что произойдет, если это волшебное значение должно будет измениться? Имеется ряд способов решить эту проблему, но возможно самый простой заключается в определении функции, которая инкапсулирует детали того, что Вы хотите сделать. Понятно, что если Вы не являетесь автором Wombat, функция будет обязательно внешней, и вы будете вызвать ее таким образом:

// может быть inline, но это не меняет сути

void nap(Wombat& w) {w.sleep(.5);}

Wombat w;

…

nap(w);

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

Если Вы самокритичны и честны сами с собой, вы увидите, что имеете эту предполагаемую несогласованность со всеми нетривиальными классами, Вы используете ее потому, что класс не может имеет любую функцию, которую пожелает како-то клиент. Каждый клиент добавляет, по крайней мере, несколько своих функций для собственного удобства, и эти функции всегда не являются методами классов. Программисты на C++ используют это, и они не думают ничего о этом. Некоторые вызовы используют синтаксис методов, а некоторые синтаксис внешних вызовов. Клиенты только ищут, какой из синтаксисов является соответствующим для тех функций, которые они хотят вызвать, затем они вызывают их. Жизнь продолжается. Это происходит особенно часто в STL (Стандартной библиотеки C++), где некоторые алгоритмы являются методами (например, size), некоторые – не методами (например, unique), а некоторые – тем и другим (например, find). Никто и глазом не моргает. Даже Вы.

Интерфейсы и упаковка

Herb Sutterr объяснил, что "интерфейс" класса (подразумевая, функциональные возможности, обеспечиваемые классом) включает также внешние функции, связанные с классом. Им также показано, что правила области видимости имен в C++ поддерживают эти изменения понятия "интерфейса" [7,8]. Это замечательные новости для моего тезиса "не друзья и не члены лучше, чем члены", потому что это означает, что решение сделать функцию, зависимую от класса, в виде не друга – не члена вместо члена даже не изменяет интерфейс этого класса! Кроме того, вывод функций интерфейса класса за границы определения класса ведет к некоторой замечательной гибкости упаковки, которая была бы иначе недоступна. В частности, это означает, что интерфейс класса может быть разбит на множество заголовочных файлов.

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

Вместо размещения всех Wombat-зависимых функций в одном заголовочном файле, предпочтительнее было бы разместить элементы интерфейса Wombat в четырех отдельных заголовках: один для функций ядра Wombat (описания функций, связанных с определением класса), и по одному для каждой дополнительной функции, определяющей, еду, сон, и размножение. Клиенты включают в свои программы только те заголовки, в которых они нуждаются. Возникающее в результате программное обеспечение не только более ясное, оно также содержит меньшее количество зависимостей, пустых для трансляции [4,9]. Этот подход, использующий множество заголовков, был принят для стандартной библиотеки (STL). Содержание namespace std размещено в 50 различных заголовочных файлах. Клиенты включают заголовки, объявляющие только части библиотеки, необходимые им, и они игнорирует все остальное.

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

Минимальность и инкапсуляция

В "Эффективном использовании C++" (Effective C++), я приводил доводы в пользу интерфейсов класса, которые являются полными и минимальный [10]. Такие интерфейсы позволяют клиентам класса делать что-либо, что они могли бы предположительно хотеть делать, но классы содержат методов не больше, чем абсолютно необходимо. Добавление функций вне минимума, необходимого для того, чтобы клиент мог сделать его работу, как я писал, уменьшает возможности повторного использования класса. Кроме того, увеличивается время трансляции для программы клиента. Джек Ривес (Jack Reeves) написал, что добавление методов сверх этих требований, нарушает принцип открытости-закрытости, производит жирные интерфейсы класса, и в конечном счете ведет к загниванию программного обеспечения [11]. Возможно увеличение числа параметров, чтобы уменьшить число методов в классе, но теперь мы имеем дополнительную причину, чтобы отказаться от этого: уменьшается инкапсуляция класса.

Конечно, минимальный интерфейс класса – не обязательно самый лучший интерфейс. Я отметил в "Эффективном использовании C++", что добавление функций сверх необходимости может быть оправданным, если это значительно увеличивает эффективность класса, делает класс, более легким в использовании или предотвращает вероятные клиентские ошибки [10]. Основываясь на его работе с различными строковыми классами, Джек Ривес отмечает, что для некоторых функций трудно ощутить, когда их делать не членами, даже если они могли быть не друзьями и не методами [12]. "Наилучший" интерфейс для класса может быть найден только после балансировки между многими конкурирующими параметрами, среди которых степень инкапсуляции является лишь одним.

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

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

Благодарности

Благодарю Арона Канду за постановку вопроса, которая привела к этой статье. Благодарю также Джека Ривеса (Jack Reeves), Херба Шутера (Herb Sutter), Дейва Смаллберга (Dave Smallberg), Андрея Александреску (Andrei Alexandrescu), Брюса Екела (Bruce Eckel), Брайна Страуструпа (Bjarne Stroustrup), и Андрю Коунига) Andrew Koenig за комментарии перед публикацией. В заключение, большая благодарность Аделе Новак (Adela Novak) за организации семинаров C++ в Люцерне (Швейцарии), которая вели к многочасовым дискуссиям, позволившим мне написать начальный проект этой статьи.

Заметки и ссылки 

[1] Scott Meyers. Effective C++: 50 Specific Ways to Improve Your Programs and Designs, First Edition (Addison-Wesley, 1991), Item 19.

[2] Scott Meyers. Effective C++, Second Edition (Addison-Wesley, 1998).

[3] The algorithm remains unchanged in current printings of Effective C++, because I'd have to also add the requisite reasoning (this article), and making such a substantial change to a book already in production simply isn't practical.

[4] Effective C++, Item 34.

[5] Erich Gamma et al. Design Patterns, Elements of Reusable Object-Oriented Software (Addison-Wesley, 1995). Also known as the GOF or ''Gang of Four'' book.

[6] James O. Coplien. Advanced C++: Programming Styles and Idioms (Addison-Wesley, 1991).

[7] Herb Sutter. ''Sutter's Mill: What's in a Class?'' C++ Report, March 1998.

[8] Herb Sutter. Exceptional C++ (Addison-Wesley, 1999), Items 31-34.

[9] John Lakos. Large-Scale C++ Software Design (Addison-Wesley, 1996).

[10] Effective C++, Item 18.

[11] Jack Reeves. ''(B)leading Edge: How About Namespaces?,'' C++ Report, April 1999.

[12] Jack Reeves. Personal communication.

Об авторе 

Scott Meyers – известный авторитет по C++; он обеспечивает консультативные услуги клиентам по всему миру. Он автор Effective C++, Second Edition (Addison-Wesley, 1998), More Effective C++ (Addison-Wesley, 1996), и Effective C++ CD (Addison-Wesley, 1999). Скотт получил его Ph. D. в области Информатики в Университета Броуна (Brown University) в 1993.

Примечания. Первая, из перечисленных выше книг переведена на русский язык:

Скотт Мейерс. Эффективное использование C++. 50 рекомендаций по улучшению ваших программных проектов: Пер. с англ. – М.: ДМК, 2000. – 240 с.: ил.

Статья, на мой взгляд, показывает, что не все так гладко в чистых методах объектно-ориентированного проектирования, если приходится прибегать к ухищрениям, присущим чисто процедурному программированию. Конечно, эффект от использования будет очевиден лишь при разработке достаточно больших программных систем, когда программу приходится развивать и модифицировать, а не создавать заново. Но статья намекает, что чисто объектные языки и методы могут оказаться в этом случае весьма неудобными. А значит: прощай Java и C#? Или их ждет ревизия?

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

Шаблоны и функции фабрики в контексте пространства имен

(Врезка)

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

// менее инкапсулированный проект

class Widget {

 …

public:

 static Widget* make(/* params */);

};

// более инкапсулированный проект

namespace WidgetStuff {class Widget {…}; Widget* make(/* params */);};

Эндрю Коунинг (Andrew Koenig) подчеркивает, что первый вариант (в котором make является статическим методом класса) позволяет написать шаблонную функцию, которая может вызывать make и не знать порождаемый ею тип:

template‹typename T›

void doSomething(/* params */) {

 // вызвать функцию фабрики для класса T

 T *pt = T::make(/* params */);

 …

}

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

template‹typename T›

void doSomething(/* params */) {

 // нельзя узнать какое T содержит пространство имен!

 T *pt =???::make(/* params */);

 …

}

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

Оглавление