Sé que esta es una pregunta común, pero todavía no puedo entenderla por completo.
En un programa C o C++ generado a partir de múltiples fuentes y archivos de encabezado diferentes, ¿se incluirá cada archivo de encabezado solo una vez en todo el código cuando se utilicen las protecciones de encabezado?
Alguien me dijo anteriormente que un archivo de encabezado (con protectores de inclusión) se incluirá solo una vez en una unidad de traducción, pero varias veces en todo el código. ¿Es esto cierto?
Si se incluye solo una vez a lo largo de todo el código, cuando un archivo desea incluirlo y el preprocesador detecta que ya se ha incluido, ¿cómo sabe ese archivo que desea utilizarlo en qué lugar del código se incluyó previamente?
Este es el proceso:
source header source header header \ / \ | / / \ / \ | / / PREPROCESSOR PREPROCESSOR | | VV preprocessed code preprocessed code | | COMPILER COMPILER | | VV object code object code \ / \ / \ / LINKER | V executablepreprocesamiento
#include es para este primer paso. Le indica al preprocesador que procese el archivo especificado e inserte el resultado en la salida.
Si A incluye B y C , y B incluye C , la salida del preprocesador para A incluirá el texto procesado de C dos veces.
Esto es un problema, ya que dará como resultado declaraciones duplicadas. Un remedio es utilizar variables de preprocesador para rastrear si se ha incluido el código fuente (también conocido como protectores de encabezado).
#ifndef EXAMPLE_H #define EXAMPLE_H // header contents #endif La primera vez, EXAMPLE_H no está definido y el preprocesador evaluará los contenidos dentro del bloque ifndef / endif . La segunda vez, saltará ese bloque. Entonces, la salida procesada cambia y las definiciones se incluyen solo una vez.
Esto es tan común que hay una directiva no estándar implementada por algunos compiladores que es más corta y no requiere elegir una variable de preprocesador única:
#pragma once // header contentsPuede averiguar cuán portátil desea que sea su código C/C++ y qué protector de encabezado usar.
Los protectores de encabezados garantizarán que el contenido de cada archivo de encabezado esté presente como máximo una vez en el código preprocesado para una unidad de traducción.
Compilando
El compilador genera código de máquina a partir de su C/C++ preprocesado.
Generalmente, los archivos de encabezado solo incluyen declaraciones, no las definiciones reales (también conocidas como implementaciones). El compilador incluye una tabla de símbolos para cualquier cosa a la que le falte una definición.
Enlace
El enlazador combina los archivos de objetos. Hace coincidir las definiciones (también conocidas como implementaciones) con las referencias a la tabla de símbolos.
Puede ser que dos archivos de objetos proporcionen la definición y el enlazador tome uno. Esto sucede si ha puesto código ejecutable en sus encabezados. Esto generalmente no sucede en C, pero sucede con mucha frecuencia en C++, debido a las plantillas.
El "código" del encabezado, ya sean declaraciones o definiciones, se incluye varias veces en todos los archivos de objetos, pero el enlazador fusiona todo eso, de modo que solo está presente una vez en el ejecutable. (Estoy excluyendo las funciones en línea, que están presentes varias veces).
El preprocesador realmente inserta un "archivo de encabezado" antes de que comience la compilación. Solo piense en ello como simplemente "reemplazar" su directiva #include .
El guardia ...
#ifndef MY_HEADER_H #define MY_HEADER_H .... #endif... se ejecuta después del reemplazo. Por lo tanto, el encabezado puede incluirse varias veces, pero el preprocesador solo pasa una vez al compilador la parte "protegida" del texto.
Por lo tanto, si hay definiciones de generación de código en el encabezado, por supuesto, se incluirán en el archivo de objeto de la unidad de compilación (también conocido como "módulo"). Si el mismo encabezado está #include en varios módulos, estos aparecerán varias veces.
Para las definiciones static , esto no es ningún problema, ya que no serán visibles más allá del módulo (también conocido como alcance del archivo ). Para las definiciones globales del programa, eso es diferente y dará como resultado un error de "definiciones múltiples".
Nota: esto es principalmente para C . Para C ++, existen diferencias significativas, ya que las clases, etc. agregan complejidad adicional a qué/cuándo se permiten múltiples objetos globales.
Un archivo de encabezado con las protecciones de inclusión apropiadas se incluirá solo una vez por unidad de traducción . Estrictamente hablando, puede incluirse varias veces, pero las partes entre el preprocesador #ifndef y #endif se omitirán en inclusiones posteriores. Si se hace correctamente, esto debería ser todo (o la mayor parte) del archivo.
Una unidad de traducción generalmente corresponde a un "archivo fuente", aunque algunas implementaciones oscuras pueden usar una definición diferente. Si un archivo de origen compilado por separado incluye el mismo encabezado, el preprocesador no tiene forma de saber que otro archivo ya lo había incluido o que cualquier otro archivo era parte del mismo proyecto.
Tenga en cuenta que cuando vincula varios archivos de origen (unidades de traducción) en un solo binario, puede encontrar problemas con múltiples definiciones si el encabezado no consta solo de declaraciones, plantillas, definiciones de funciones que están marcadas inline o definiciones de variables estáticas. . Para evitar esto, debe declarar las funciones en el encabezado y definirlas en un archivo fuente separado, que vincula junto con sus otros archivos fuente.