Posted by RetroMan | C++, Documentación

Julio Cesar tenía la premisa de “Divide y Triunfaras”, y muy mal no le fue en sus conquistas. Vamos a ver como organizar nuestro código fuente dividiéndolo en fragmentos de código más fáciles y cómodos de manejar, vamos a aprender cómo hacerlo y bajo qué criterios.

Muchos programas simples se pueden escribir en un solo archivo fuente en C++, pero, cualquier proyecto serio va a necesitar dividir en varios archivos con el fin de ser más manejable.

Sin embargo, muchos programadores que recién comienzan no se dan cuenta de cuál es la importancia de esto, sobre todo porque algunos ya lo intentaron y se encontraron con tantos problemas que decidieron que no valía la pena el esfuerzo.

Este artículo intenta explicar por qué hacerlo y en un próximo artículo cómo hacerlo correctamente.

Voy a llamar a los archivos estándar de C ++ (por lo general con extensión .cpp) “archivos de codigo fuente”. Esto será para distinguirlos de los “archivos de cabecera” (por lo general con extensión .h o .hpp).

¿Por qué dividir el código en varios archivos?

La primera pregunta que algunos programadores novatos se hacen cuando ven un directorio lleno de archivos de código fuente es, “¿por qué no está todo en un solo archivo?”

La división de cualquier proyecto de tamaño razonable nos provee de algunas ventajas, las más significativas de las cuales son las siguientes:

  • Acelerar la compilación – la mayoría de los compiladores trabajan en un archivo a la vez. Así que si todos sus 10000 líneas de código se encuentra en un archivo, y cambian una línea, entonces usted tiene que recompilar 10000 líneas de código. Por otro lado, si sus 10000 líneas de código se distribuyen uniformemente a través de 10 archivos, a continuación, cambiar una línea única requerirá compilar solo 1.000 líneas de código. Las 9000 líneas en los otros 9 archivos no necesitarán volver a compilarse.
  • Aumentar organización – La división de su código a lo largo de líneas lógicas, será más fácil para usted (y los otros programadores del proyecto) para encontrar funciones, variables, declaraciones, etc.
  • Facilitar la reutilización de código – Si el código está cuidadosamente dividido en secciones que operan en gran medida de forma independiente el uno del otro, esto le permite utilizar ese código en otro proyecto, que le ahorra un montón de tiempo y trabajo en volver a escribir el código.
  • Compartir código entre los proyectos – El principio aquí es el mismo que con el tema reutilización. Al separar cuidadosamente código en determinados archivos, se hace posible que los múltiples proyectos que utilizan algunos de los mismos archivos de código sin duplicarlos. El beneficio de compartir un archivo de código entre los proyectos y no sólo utilizando la copia y pega es que cualquier corrección de errores realizados en ese archivo o archivos de un proyecto afectará el otro proyecto, por lo que ambos proyectos pueden estar seguros de utilizar la versión más reciente del código.
  • Dividir las responsabilidades de codificación entre los programadores – Para grandes proyectos, esta es quizás la principal razón para la separación de código en varios archivos. Sistemas de gestión de configuración y los sistemas de control de versiones como CVS o Git ayudarle con esto.

Ahora que ya estás convencido de que hay beneficios para la división de tu proyecto en varios archivos más pequeños. Así que, ¿cómo hacerlo? Aunque algunas de las decisiones que tomes serán razonablemente arbitrarias, hay algunas reglas básicas que debes seguir.

En primer lugar, mira cómo dividir el código en secciones. A menudo esto es mediante su división en subsistemas separados, o “módulos”, como el sonido, la música, gráficos, manejo de archivos, base de datos, etc.

Crea nuevos archivos con nombres significativos para saber de un vistazo qué tipo de código es el que contienen.

A veces es necesario que un módulo se divida en dos o más archivos, ya que podría tener sentido hacerlo por razones lógicas.

Una vez que haya dividirlo según este criterio los archivos de código fuente, el siguiente paso es considerar lo que va a entrar en los archivos de cabecera. Básicamente consiste en poner el código que suele estar en la parte superior del archivo de código fuente en un archivo de cabecera separado.

EL código que se pone  en un encabezado por lo general incluye algunos o todos de los siguientes:

  • definiciones de clases y struct
  • typedefs
  • prototipos de funciones
  • variables globales
  • constantes
  • macros #defined
  • directivas #pragma

Peligros potenciales

Las reglas dadas arriba son bastante generales y sólo sirven como punto de partida para la organización de su código. En casos sencillos, se puede seguir esas directrices. Sin embargo, hay algunos detalles más que se tienen que considerar.

En mi experiencia, hay cuatro errores básicos que las personas enfrentan cuando entran en el oscuro mundo de los archivos de cabecera definidos por el usuario.

  • Los archivos de código fuente ya no se compilan ya que no pueden encontrar las funciones o variables que necesitan.
  • Definiciones duplicadas en una clase o identificador se incluye dos veces en un archivo de origen.
  • Duplicar instancias de objetos dentro del código que compila bien. Este es un error que une, a menudo difícil de entender

Conclusión

Si se realiza correctamente, la organización de los archivos de esta manera puede acelerar su desarrollo sin perjudicar en absoluto o introducir algún problema adicional. A pesar de que parece que hay mucho que considerar cuando se hace así, con el tiempo se convierte en una práctica habitual.

Sólo recuerde estos puntos clave:

  • Divida el código siguiendo el criterio de identificar los modulos logicos
  • Use los archivos de .cpp para la implementación y los archivos .hpp para la interfaz

Responses are currently closed, but you can trackback from your own site.