c++ - sobre - Separe las carpetas "incluir" y "src" para el código de nivel de aplicación?

introducción a android studio incluye proyectos reales y el código fuente pdf (10)

Casi siempre creo carpetas include y src para dividir mi código fuente. Creo que hace que la carpeta esté menos saturada y los archivos son más fáciles de encontrar en mi IDE. Pero creo que esto es solo una cuestión de gusto.

Cualquiera de los métodos es válido. Depende del estilo de codificación que desee seguir cómo lo hace.

Esta pregunta concierne principalmente al desarrollo C ++ estilo Unix / Linux. Veo que muchas bibliotecas C ++ almacenan sus archivos de encabezado en una carpeta "incluir" y los archivos fuente en una carpeta "src". En aras de la conformidad, adopté esto en mi propio código. Pero no me queda claro si esto debería hacerse también para el código de la aplicación . He visto algunos casos en los que se usa una estructura de directorio plana para eso. ¿Cuál sería el enfoque recomendado?

Coloco include (encabezado) y archivos fuente en el mismo directorio (carpeta). Creo carpetas diferentes para diferentes temas. Me siento frustrado cuando intento encontrar archivos de encabezado (mientras estoy depurando y también para investigar). En algunas tiendas, solo hay dos carpetas: fuente e incluye. Estos directorios tienden a crecer exponencialmente. Reutilizar el código se convierte en una pesadilla en el mejor de los casos.

En mi humilde opinión, creo que organizar por tema es mejor. Cada carpeta de temas debe compilarse en al menos una biblioteca. Los diferentes proyectos pueden incluir fácilmente los temas al buscar o incluir las carpetas. Los proyectos solo necesitan incluir las bibliotecas. Los motores de compilación inteligente pueden enumerar las carpetas de temas como dependencias. Esto acelera el proceso de construcción.

La organización del tema también agrega un poco de seguridad al proyecto. Se reduce el daño accidental a los archivos (como eliminar los incorrectos o reemplazarlos con versiones diferentes) ya que los archivos están ubicados en directorios diferentes. La eliminación de archivos en la carpeta "Persona" no afectará a los archivos en la carpeta "Forma".

Esta es solo mi opinión, su kilometraje puede variar.

Mucho depende del tamaño del proyecto involucrado. Hasta unas pocas docenas de archivos más o menos, mantenerlos en un directorio tiende a ser más conveniente. Para una aplicación más grande que incluye cientos o miles de archivos, comienzas a buscar formas de separarlos (aunque en los proyectos en los que he trabajado, se hizo más en líneas funcionales que src / include). Entre esos, probablemente sea cuestionable.

No hay una clara ventaja para ninguno en mi opinión. Finalmente decidí mantener juntos los archivos de programa y encabezado porque mi editor (Visual SlickEdit) proporciona características referenciales adicionales cuando no están separados.

También los separo, pero no estrictamente en la extensión, sino en el acceso del archivo.

Supongamos que tiene un módulo que gestiona la información del cliente y utiliza 2 clases para hacer esto: Cliente, CustomerValidityChecker. Supongamos también que otras partes de su aplicación solo necesitan saber acerca de la clase Cliente, y que CustomerValidityChecker solo lo utiliza la clase Cliente para realizar alguna comprobación. En base a estas suposiciones, almaceno los archivos de esta manera:

Carpeta pública (o carpeta de inclusión):

cliente.h

Carpeta privada (o carpeta de origen):

customer.cpp
customervaliditychecker.h
customervaliditychecker.cpp

De esta forma, queda inmediatamente claro para las personas que llaman de su módulo qué partes son accesibles (públicas) y cuáles no.

Tenemos un sistema de compilación que genera automáticamente nuestros archivos make. Una cosa que hace es descender recursivamente en cualquier subdirectorio y compilarlos como bibliotecas, vinculándolos con los objetos del directorio principal para crear la aplicación. (En la práctica, estos "subdirectorios" suelen ser enlaces simbólicos). Las bibliotecas son estáticas a menos que el nombre del directorio termine en ".so". Una cosa que es agradable acerca de esto es que una compilación completa de nuestro sistema, que tiene muchos ejecutables, no tiene que compilar repetidamente las bibliotecas comunes.

Sin embargo, como resultado de esto, no hay separación de encabezados y fuentes. Y nunca ha sido un problema. Honestamente, creo que es mejor así porque los encabezados y los archivos fuente tienen una ubicación común, y puedes tomar un directorio y saber que tienes todo lo que necesitas para usarlo. También funciona de maravilla con la función "external" de Subversion y funciones similares en otros VCS.

Un último lugar donde falla una separación include / src es si usa generadores de código, como flex, bison o gengetopts. Averiguar dónde estas herramientas deberían poner sus productos para que se construyan es complicado si has difundido las cosas.

Tenemos un sistema de compilación que usa esta regla. Este sistema de compilación es un conjunto de scripts de sconspiracy para configurar SCons y dedicados al mundo de C ++. Puede ver un ejemplo que usa estas herramientas: fw4spl

Tiene sentido separarlos para las bibliotecas compartidas porque pueden distribuirse en un formulario compilado sin la fuente. He visto proyectos que separan los encabezados "públicos" (encabezados a los que se puede acceder desde el código fuera de su proyecto o biblioteca) mientras deja los encabezados "privados" y los archivos fuente en el mismo directorio. Creo que es bueno usar un enfoque coherente si está escribiendo una biblioteca compartida o un código de nivel de aplicación porque nunca se sabe cuándo se puede convertir algo que se ha escrito en el nivel de la aplicación en una biblioteca de nivel inferior que se comparte con múltiples proyectos.

Yo no hago esto; parece que hay poca ventaja en eso. Como los encabezados tienden a tener una extensión diferente de los archivos fuente, puede hacer que su editor los muestre por separado si realmente siente la necesidad. Visual Studio lo hace de manera predeterminada, pero lo desactivo porque prefiero verlos juntos.

Conclusión : las fuentes y los encabezados que todavía están cambiando entran /src . El código que ha cristalizado debe ir en /lib & /include (de hecho, puede guardar todos los .lib y sus .h s en /lib ).

Mantenga fuentes y encabezados propios, siempre que sean (a) específicos de este proyecto o (b) aún no se hayan tenido en cuenta como bibliotecas compartidas.
Una vez que ciertas fuentes en el proyecto principal se han tenido en cuenta como una biblioteca (relativamente estable), coloque .a o .lib en /lib , y su encabezado de interfaz pública en /include .
Todas las bibliotecas de terceros y sus encabezados de interfaz pública también entran en /lib & /include .

Como otros señalan, a menudo es más compatible para herramientas / IDE acceder a .h / .c desde una carpeta. Pero desde una visión organizacional, puede ser útil separar el código local cambiante del código lib estable.