¿Por qué es válido incluir un archivo de encabezado dos veces en C++?

Question

#include "DLLDefines.h" 
#include "DLLDefines.h" 

Lo anterior realmente pasó la compilación, pero ¿por qué?

Answer 1

Probablemente tenga #define en DLLDefines.h alrededor de su código que impida que se incluya dos veces.

#ifndef DLLDEFINES_H 
#define DLLDEFINES_H 
// your code 
#endif 

Answer 2

Depende del archivo de encabezado; no hay restricción de idioma en múltiples incluye del mismo archivo.

Algunos archivos están diseñados para incluirse varias veces (por ejemplo, <assert.h> se pueden incluir varias veces para activar o desactivar 'assert).

Muchos archivos son seguros para ser incluidos varias veces porque tienen incluyen guardias, otros no son y deben incluirse solo una vez en una unidad de traducción o incluso en un programa.

Answer 3

incluir no tiene nada que ver con el lenguaje C o C++. Es una directiva para el preprocesador traer un archivo. Al preprocesador no le importa qué archivo se trae y no debería. Podría ser perfectamente aceptable para hacer esto:

void Foo::SomeFunc(int cond) 
{ 
    switch (cond) { 
    case kThisCase: 
#include "longFirstCase.h" 
     break; 
    case kSecondCase: 
#include "longSecondCase.h" 
     break; 
    case kThirdCase: 
#include "longFirstCase.h" 
#include "longSecondCase.h" 
     break; 
    } 
} 

he visto el mismo archivo incluye varias veces como un mecanismo de configuración también.

De acuerdo, hay una serie de formas de factorizar ese ejemplo que son mejores, pero el hecho es que puede haber razones perfectamente buenas por las que desearía y, por lo tanto, no hay restricciones en el uso.

Answer 4

Se llama include guard.

#ifndef GRANDFATHER_H 
#define GRANDFATHER_H 

struct foo { 
    int member; 
}; 

#endif 

Cita de Wikipedia:

In the C and C++ programming languages, an #include guard, sometimes called a macro guard, is a particular construct used to avoid the problem of double inclusion when dealing with the #include directive. The addition of #include guards to a header file is one way to make that file idempotent.

Ver enlace anterior para obtener más información.

Answer 5

Siempre que la inclusión múltiple de archivos de encabezado no viole ODR (Regla de definición única) $ 3.2, el código está bien formado.

Answer 6

DLLDefines.h también puede tener #pragma una vez en la parte superior , #pragma una vez asegura que el archivo se incluye una sola vez.

Answer 7

Bueno, es legal porque tiene para ser legal. Porque a menudo incluye el mismo encabezado varias veces sin siquiera darse cuenta.

Puede incluir dos encabezados en un archivo .cpp, cada uno de los cuales incluye una cantidad de archivos, algunos de los cuales pueden estar incluidos por ambos.

Por ejemplo, todos los encabezados de biblioteca estándar (por ejemplo, string o vector por ejemplo) están probablemente incluidos en la mayoría de sus encabezados. Así que rápidamente termina con el mismo encabezado indirectamente incluido varias veces en el mismo archivo .cpp.

Así que en resumen, tiene para funcionar, o todos los códigos C++ se desmoronarían.

En cuanto a cómo funciona, generalmente a través de incluye guardias. Recuerde que #include solo realiza un simple copiar/pegar: inserta el contenido del archivo de encabezado en el sitio #include.

Así que digamos que usted tiene un archivo de cabecera header.h con el siguiente contenido:

class MyClass {}; 

Ahora vamos a crear un archivo CPP que incluye dos veces:

#include "header.h" 
#include "header.h" 

el preprocesador se expande esto a:

class MyClass {}; 
class MyClass {}; 

que obviamente causa un error: se define la misma clase d dos veces. Entonces eso no funciona. En su lugar, vamos a modificar el encabezado para contener incluyen guardias:

#ifndef HEADER_H 
#define HEADER_H 

class MyClass {}; 

#endif 

Ahora, si incluimos dos veces, obtenemos lo siguiente:

#ifndef HEADER_H 
#define HEADER_H 

class MyClass {}; 

#endif 

#ifndef HEADER_H 
#define HEADER_H 

class MyClass {}; 

#endif 

y esto es lo que sucede cuando el preprocesador procesa:

#ifndef HEADER_H // HEADER_H is not defined, so we enter the "if" block 
#define HEADER_H // HEADER_H is now defined 

class MyClass {};// MyClass is now defined 

#endif   // leaving the "if" block 

#ifndef HEADER_H // HEADER_H *is* defined, so we do *not* enter the "if" block 
//#define HEADER_H 
// 
//class MyClass {}; 
// 
#endif   // end of the skipped "if" block 

Por lo tanto, el resultado final es que MyClass obtuve define sólo una vez , e aunque el encabezado se incluyó dos veces. Y entonces el código resultante es válido.

Esta es una propiedad importante de los archivos de encabezado. Defina siempre sus encabezados para que sea válido incluirlos varias veces.