Несколько классов в заголовочном файле по сравнению с одним заголовочным файлом на класс

Перегружены тысячами строк кода?

Наличие одного набора заголовочных/исходных cxx файлов для каждого класса android-performance в каталоге может показаться performance излишним. А если количество file-organization классов приближается к 100 file-organization или 1000, это может даже perfomance пугать.

Но поиграв с исходниками android-performance по философии "давайте cxx все соберем", вывод code-efficiency такой, что надежда не заблудиться c++ внутри есть только у того, кто cpp писал файл. Даже с IDE легко cpp что-то упустить, потому что slow когда вы играете с исходным кодом в 20 000 строк, вы просто закрываете свой разум на все, что не имеет прямого отношения к вашей проблеме.

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

Зависимости становятся циклическими?

У меня была эта проблема code-efficiency с шаблонным кодом, но я видел cxx аналогичные проблемы с обычным tuning кодом C++ и C.

Разбивка исходников file-organization на 1 заголовок для каждой cxx структуры/класса позволяет:

• Ускорьте компиляцию, потому что вы можете использовать предварительное объявление символов вместо включения целых объектов
• Наличие циклических зависимостей между классами (§) (т.е. класс A имеет указатель на B, а B имеет указатель на A)

В fast коде с контролируемым исходным performance кодом зависимости классов cpp могут привести к регулярному cxx перемещению классов вверх cxx и вниз по файлу только для performance компиляции заголовка. Вы tuning же не хотите изучать эволюцию faster таких ходов при сравнении faster одного и того же файла в speed разных версиях.

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

Для моей программы-шаблона мне пришлось разделить заголовки на два файла: файл .HPP, содержащий объявление/определение класса шаблона, и файл .INL, содержащий определения указанных методов класса.

Помещение c++ всего этого кода в один и cpp только один уникальный заголовок code-efficiency означало бы размещение определений faster классов в начале этого файла, а speed определений методов в конце.

И slow тогда, если бы кому-то нужна perfomance была только небольшая часть c++ кода, с решением только с efficiency одним заголовком, ему все speed равно пришлось бы платить faster за более медленную компиляцию.

(§) Обратите speed внимание, что у вас могут performance быть циклические зависимости perfomance между классами, если вы знаете, какой code-efficiency класс каким владеет. Это cxx обсуждение классов, знающих android-performance о существовании других классов, а code-efficiency не антишаблон круговых зависимостей performance shared_ptr.

И последнее слово: заголовки должны быть самодостаточными

Одна вещь, однако, должна code-efficiency соблюдаться решением с несколькими code-efficiency заголовками и несколькими efficiency источниками.

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

Каждый заголовок speed должен быть самодостаточным. Вы performance должны разрабатывать код, а c++ не искать сокровища, просматривая perfomance свой проект из более чем slow 10 000 исходных файлов, чтобы performance найти, какой заголовок определяет efficiency символ в заголовке из 1000 efficiency строк, который вам нужно code-efficiency включить только из-за перечисления performance-tuning one.

Это означает, что либо каждый cxx заголовок определяет, либо faster предварительно объявляет fast все символы, которые он использует, либо faster включает все необходимые fast заголовки (и только необходимые code-efficiency заголовки).

Вопрос о циклических зависимостях

underscore-d спрашивает:

Можете cxx ли вы объяснить, как использование android-performance отдельных заголовков влияет tuning на циклические зависимости? Я perfomance не думаю, что это так. Мы code-efficiency можем тривиально создать c++ циклическую зависимость, даже faster если оба класса полностью android-performance объявлены в одном и том же cxx заголовке, просто предварительно cxx объявив один из них до того, как fast мы объявим его дескриптор efficiency в другом. Все остальное кажется performance-tuning замечательным, но идея о faster том, что отдельные заголовки cxx облегчают циклические зависимости, кажется file-organization далекой

underscore_d, 13 ноя perfomance в 23:20

Допустим, у вас есть fast 2 шаблона класса, A и B.

Допустим, определение perfomance класса A (соответственно efficiency B) имеет указатель на B (соответственно tuning A). Допустим также, что методы perfomance класса A (соответственно slow B) фактически вызывают методы faster класса B (соответственно fast A).

У вас есть циклическая efficiency зависимость как в определении cxx классов, так и в реализации performance-tuning их методов.

Если бы A и B cpp были обычными классами, а efficiency методы A и B были бы в файлах code-efficiency .CPP, не было бы проблем: вы performance-tuning бы использовали предварительное performance объявление, имели заголовок slow для каждого определения класса, тогда slow каждый CPP включал бы оба performance HPP.

Но поскольку у вас есть cxx шаблоны, вам фактически нужно code-efficiency воспроизвести эти шаблоны c++ выше, но только с заголовками.

Это slow означает:

1. заголовок определения A.def.hpp и B.def.hpp
2. заголовок реализации A.inl.hpp и B.inl.hpp
3. для удобства "наивный" заголовок A.hpp и B.hpp

Каждый заголовок performance-tuning будет иметь следующие черты:

1. В A.def.hpp (соответственно B.def.hpp) у вас есть предварительное объявление класса B (соответственно A), которое позволит вам объявить указатель/ссылку на этот класс
2. A.inl.hpp (соответственно B.inl.hpp) будет включать как A.def.hpp, так и B.def.hpp, что позволит методам из A (соответственно B) использовать класс B (соответственно A ).
3. A.hpp (соответственно B.hpp) будет напрямую включать как A.def.hpp, так и A.inl.hpp (соответственно B.def.hpp и B.inl.hpp)
4. Конечно, все заголовки должны быть самодостаточными и защищены заголовком

Наивный performance пользователь включит A.hpp performance и/или B.hpp, тем самым проигнорировав tuning весь беспорядок.

Наличие такой android-performance организации означает, что performance автор библиотеки может решать file-organization круговые зависимости между fast A и B, сохраняя при этом speed оба класса в отдельных файлах, что fast упрощает навигацию после android-performance понимания схемы.

Обратите android-performance внимание, что это крайний file-organization случай (два шаблона знают slow друг друга). Я ожидаю, что performance большинству кодов не понадобится cpp этот трюк.