Внутренние определения типов в C ++ - хороший или плохой стиль?

Я считаю, что это отличный стиль, и сам им пользуюсь. Всегда лучше ограничивать область имен, насколько это возможно, и использование классов - лучший способ сделать это в C ++. Например, стандартная библиотека C ++ интенсивно использует определения типов внутри классов.

Он служит заявлением о намерениях - в приведенном выше примере класс Lorem предназначен для подсчета ссылок с помощью boost :: shared_ptr и сохранения в векторе.

Это именно то, чего он не.

Если я вижу в коде «Foo :: Ptr», я совершенно не понимаю, является ли это shared_ptr или Foo * (в STL есть определения типов :: pointer typedef, которые являются T *, помните) или что-то еще. Esp. если это общий указатель, я вообще не предоставляю typedef, но сохраняю использование shared_ptr явно в коде.

На самом деле, я почти никогда не использую typedef вне метапрограммирования шаблонов.

STL делает такие вещи постоянно

Дизайн STL с концепциями, определенными в терминах функций-членов и вложенных определений типов, является историческим тупиком, современные библиотеки шаблонов используют бесплатные функции и классы свойств (см. Boost.Graph), поскольку они не исключают встроенные типы из моделирование концепции и потому, что это упрощает адаптацию типов, которые не были разработаны с учетом концепций заданных библиотек шаблонов.

Не используйте STL как повод для тех же ошибок.

Typedef - это то, на чем основанный на политике дизайн и черты построены в C ++, поэтому сила универсального программирования в C ++ проистекает из самих определений типов.

Typdef - это определенно хороший стиль. И все ваши «причины, которые мне нравятся» хороши и правильны.

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

Вы можете переместить typedef за пределы класса, но Class :: ptr настолько красивее, чем ClassPtr, что я этого не делаю. Это похоже на пространства имен, как для меня - вещи остаются связанными в пределах области видимости.

Иногда я делал

Trait<Loren>::ptr
Trait<Loren>::collection
Trait<Loren>::map

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

STL делает такие вещи все время - определения типов являются частью интерфейса для многих классов в STL.

reference
iterator
size_type
value_type
etc...

все это typedef, которые являются частью интерфейса для различных классов шаблонов STL.

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

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

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

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

Поэтому перед их использованием следует учесть несколько моментов.

• Кому-нибудь еще нужны эти typedef? Часто ли этот класс используется другими классами?
• Могу ли я сократить использование или скрыть класс? (В случае сокрытия вы также можете подумать об интерфейсах.)
• С кодом работают другие люди? Как они это делают? Они подумают, что это проще, или запутаются?

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

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

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