Incluir directiva

Tanto C como C++ (anterior a C++20) se utilizan normalmente con el preprocesador de C, que reemplaza una #includelínea de directiva con el contenido del archivo especificado. La ruta del archivo se encierra entre comillas dobles (p. ej., "Header.h" ) o entre corchetes angulares (p. ej., <Header.h> ). ^{[ 1 ]} Algunos preprocesadores localizan el archivo de inclusión de forma diferente según los delimitadores; tratan una ruta entre comillas dobles como relativa al archivo de inclusión y una ruta entre corchetes angulares como ubicada en uno de los directorios de la ruta de búsqueda del sistema configurada. ^{[ 2 ]}

Ejemplos de declaraciones:

// Incluye el archivo de cabecera estándar de C 'stdio.h'; probablemente sea un archivo con ese nombre #include <stdio.h> // Incluye el archivo de cabecera estándar de C++ 'vector'; puede o no ser un archivo #include <vector> // Incluye un archivo de cabecera personalizado llamado 'MyHeader.h' #include "MyHeader.h"

La directiva include permite el desarrollo de bibliotecas de código que:

• ayuda a garantizar que todos utilicen la misma versión de una definición de diseño de datos o código de procedimiento en todo un programa.
• Permite realizar referencias cruzadas fácilmente sobre dónde se utilizan los componentes en un sistema.
• Programas de cambio centralizados/generales de fácil uso cuando sea necesario (solo se debe editar un archivo).
• Ahorra tiempo reutilizando diseños de datos.

Las directivas include no admiten patrones de comodines , por lo que, por ejemplo, no incluirían todos los archivos *.h en el directorio actual.#include"*.h"

#pragma una vezentero sumar ( entero , entero );int triple ( int x ) { return add ( x , add ( x , x )); }

#incluir "Add.h"int triple ( int x ) { return add ( x , add ( x , x )); }

import < stdio . h > ; // admitir esto es opcional import < vector > ; // admitir esto es obligatorio por el estándar export import "MyHeader.h" ;

exportar opcionalmente importar nombre_del_módulo;

// importa la biblioteca estándar de C++ import std ;// importa un módulo llamado "acme.project.math.BigInteger" import acme . project . math . BigInteger ;// importa un módulo llamado "wikipedia.util.logging.Logger" y lo reexporta // cualquier archivo que importe este módulo importará transitivamente wikipedia.util.logging.Logger export import wikipedia . util . logging . Logger ;

constexpr char ICON_DISPLAY_DATA [] = { #embed "art.png" };// especifique cualquier tipo que pueda inicializarse a partir de expresiones constantes enteras lo hará constexpr char RESET_BLOB [] = { #embed "data.bin" };// los atributos funcionan igual de bien alignas ( 8 ) constexpr char ALIGNED_DATA_STRING [] = { #embed "attributes.xml" };int main () { return #embed </dev/urandom> limit(1) ; }

Objective-C , al igual que C, también utiliza archivos de cabecera y tiene una #includedirectiva. Sin embargo, también tiene una #importdirectiva, que se comporta igual que #include, con la única diferencia de que #importgarantiza que la inclusión del archivo nunca ocurrirá más de una vez, sin el uso de guardas #include o #pragma once .

#importar <Foundation/Foundation.h> #importar "MyClass.h"

La #importdirectiva Objective-C no debe confundirse con la importinstrucción en C++ (que importa un módulo), ni con la directiva de Microsoft Visual C++#import , que importa una biblioteca de tipos. ^{[ 8 ]}

COBOL (y también RPG IV ) permite a los programadores copiar copybooks en el código fuente del programa , lo que es similar a la inclusión pero permite reemplazar texto. La palabra clave de COBOL para la inclusión es COPY, y el reemplazo se realiza usando la REPLACING ... BY ...cláusula. Una directiva include ha estado presente en COBOL desde COBOL 60, pero cambió de la original INCLUDE^{[ 9 ]} a COPYen 1968. ^{[ 10 ]}

Fortran no requiere archivos de cabecera propiamente dichos . Sin embargo, Fortran 90 y versiones posteriores cuentan con dos características relacionadas: includesentencias y módulos. Las primeras permiten compartir un archivo común que contiene interfaces de procedimientos, de forma similar a una cabecera de C, aunque la especificación de una interfaz no es obligatoria para todas las variantes de procedimientos de Fortran. Este enfoque no es común; en su lugar, los procedimientos suelen agruparse en módulos que pueden referenciarse mediante una usesentencia en otras regiones del código. Para los módulos, el compilador genera automáticamente la información de la interfaz de tipo cabecera, que normalmente se coloca en archivos de módulo independientes, si bien algunos compiladores la han incluido directamente en los archivos objeto. La especificación del lenguaje no exige la creación de archivos adicionales, aunque las interfaces de procedimientos de los módulos se propagan casi universalmente de esta manera.

El lenguaje Haskell , que puede usar el preprocesador de C escribiendo {-# LANGUAGE CPP #-}, tiene acceso a la #includedirectiva.

La mayoría de los compiladores de Pascal admiten la directiva de compilador $ior , en la que la directiva or sigue inmediatamente al inicio de un bloque de comentarios en forma de$include$i$include

• {$i ''filename.pas''}
• (*$i ''filename.inc''*)
• {$include ''filename.inc''}
• (*include ''filename.pas''*)

Donde la directiva $i/ $Io $include/ $INCLUDEno distingue entre mayúsculas y minúsculas , y filename.pas o filename.inc es el nombre del archivo que se va a incluir. (Ha sido práctica común nombrar los archivos de inclusión de Pascal con la extensión .inc , pero esto no es obligatorio). Algunos compiladores, para evitar la recursión ilimitada, limitan la invocación de un archivo de inclusión a un cierto número, prohíben invocarse a sí mismo o a cualquier archivo actualmente abierto, o están limitados a un máximo de un archivo de inclusión a la vez, por ejemplo, un archivo de inclusión no puede incluirse a sí mismo ni a otro archivo. Sin embargo, el programa que incluye otros archivos puede incluir varios, solo uno a la vez.

En PHP , la includedirectiva hace que se incluya y evalúe otro archivo PHP. ^{[ 11 ]} Comandos similares son require, que en caso de no poder incluir producirá una excepción fatal y detendrá el script, ^{[ 12 ]} y include_oncey require_once, que impiden que un archivo se incluya o requiera de nuevo si ya se ha incluido o requerido, evitando el problema de doble inclusión de C.

Rust tiene la include!macro, que se comporta esencialmente igual que #includeen C. Analiza el elemento como una expresión o como un elemento, dependiendo del contexto. ^{[ 13 ]}

¡Incluir! ( "generated_code.rs" );fn main () { // ... usar elementos de generated_code.rs }

Sin embargo, a diferencia de C, este no es el método habitual para separar e incluir código. En su lugar, Rust utiliza módulos , que preservan los espacios de nombres y la encapsulación.

Rust también admite una include_str!macro que permite incluir un archivo completo y almacenarlo en una cadena. ^{[ 14 ]} De manera similar, existe una include_bytes!macro.

let my_str : & ' static str = include_str! ( "spanish.in" ); let bytes : & ' static [ u8 ] = include_bytes! ( "spanish.in" );

Otros idiomas notables con una directiva include:

• include...( Fortran , MASM )
• <!--#include ...-->(HTML SSI )
• var...=require("...");(JavaScript con CommonJS )
• <%@include...%>( JSP )
• %include ...( PL/I )
• /COPY QCPYLESRC,QBC(RPG IV – el primer argumento es el nombre del archivo, el segundo argumento es el libro de copias)
• local...=require("...")( Lua )

Los lenguajes modernos (por ejemplo, Haskell y Java ) tienden a evitar la directiva include, prefiriendo módulos y semántica de importación/exportación. Algunos de estos lenguajes (como Java y C# ) no utilizan declaraciones anticipadas y, en su lugar, los identificadores se reconocen automáticamente a partir de los archivos fuente y se leen directamente de los símbolos de la biblioteca dinámica (normalmente referenciados con directivas importo using).