Включая стиль заголовочных файлов - C++

в качестве небольшого доработки, я предлагаю вам разрешить файлы CC в Module1 для доступа к их .h Файлы напрямую:

module1/%.cc: -I $ROOT/includes/module1

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

// module1/abc.cc
#include <abc.h>
#include <module2/def.h>

Я предпочитаю 2-й способ

#include <module1/foo.h>

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

Руководство по стилю Google C ++ имеет раздел в этом, где они обсуждают упорядочение и именование включения. Он в основном согласен с тем, что было сказано в других ответах до сих пор, но стоит посмотреть, как это очень специфично.

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

Насколько это далеко от разделяющего источника и включает файлы на два разных под деревья: почему бы не проживают заголовки рядом с исходными файлами? Это облегчает их сопоставить. Если вы не ожидаете, что другие проекты используют ваши заголовки и просто связываете со своими дворами, я думаю.
<плечами />

Использование ILMerge : Объединение сборок .NET с помощью ILMerge

ILMerge хорошо работает и делает это, по большей части.

Имейте в виду, что есть проблемы, если вы делаете это с сборками WPF, содержащими Я подозреваю, что проекты Workflow 4 могут иметь те же проблемы. Встроенный Xaml неправильно объединяется с ILMerge.

Существуют некоторые коммерческие инструменты, однако утверждение о поддержке объединения сборки с проектами WPF, включая .NET Reactor и SmartAssembly .

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

Я не использую пути в #include директивы. По моему опыту они всегда вызывают проблемы на этапе обслуживания. Многие компиляторы позволяют указать дерево поиска для файлов заголовка.

Файлы могут перемещаться

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

Перемещение файлов без измененийки

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

На мой взгляд, пути в #include директивы являются злом. Люди, которые делают это, должны быть перепочечены или отправлены другим компаниям.

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

Давайте предположим, что у вас также есть каталог root / src / common с целью моего примера

// in src/module1/foo.cpp
#include "module1/foo.h"

#include "../common/stringProcessing.h"

включает

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

Также всегда есть риск, используя «...», что он не идет туда, куда вы думаете из-за символической связи, пройденной назад: /

Источник

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

Это позволяет: - не загромождать -I со всеми возможными каталогами SRC - Легко найти файл среди ваших источников - Легко тестируйте на зависимости от ваших источников (GREP для .. )

MICC

Если я должен набрать

#include "module/foo.h"

, то я ожидаю использовать:

module::Foo myClass;

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

Требование одна библиотека - одно пространство имен с одинаковыми именами, позволяет легко ориентироваться на одном ~ 300 или ~ 400 компонентов, которые мы имеем на работе: нам пришлось работать какой-то способ организовать их!

Это означает, что ваш начальный макет переработан как (для модуля модуля ):

root
-- include
---- module
------ part1
------ part2
-- src
---- part1
---- part2

, и вы тогда используете следующую директиву: -I / Path ../ root / включить И я ожидаю, что вы создадите либо библиотеку libmodule.so или модуль двоичных данных.