Incluir diretiva - Include directive

Muitas linguagens de programação e outros arquivos de computador têm uma diretiva , freqüentemente chamada de include(às vezes copyou import), que faz com que o conteúdo de um segundo arquivo seja inserido no arquivo original. Esses arquivos incluídos são chamados de copybooks ou arquivo de cabeçalho s. Eles são freqüentemente usados ​​para definir o layout físico dos dados do programa, partes do código procedural e / oudeclarações de encaminhamento,enquanto promovem oencapsulamentoe a reutilização do código.

Propósito

A includediretiva permite que bibliotecas de código sejam desenvolvidas, o que ajuda a:

  • garantir que todos usem a mesma versão de uma definição de layout de dados ou código de procedimento em todo o programa,
  • referência cruzada facilmente onde os componentes são usados ​​em um sistema,
  • mudar facilmente os programas quando necessário (apenas um arquivo mestre deve ser editado, em vez de modificar cada instância, um tipo de dados idêntico é usado ou uma função é chamada), e
  • economize tempo por não precisar codificar layouts de dados extensos (pequenos, mas úteis).

Um exemplo de situação que se beneficia do uso de uma diretiva de inclusão é quando se refere a funções em um arquivo diferente. Suponha que tenhamos uma função addem um arquivo, que é então declarada (com um protótipo de função ) e então referida em um segundo arquivo de origem da seguinte maneira: 

int add(int, int);

int triple(int x)
{
    return add(x, add(x, x));
}

Uma desvantagem desse método é que o protótipo deve estar presente em todos os arquivos que usam a função. Outra desvantagem é que se o tipo de retorno ou os argumentos da função forem alterados, esses protótipos terão que ser atualizados. Colocar o protótipo em um único arquivo separado evita esses problemas. Supondo que o protótipo seja movido para o arquivo add.h, o segundo arquivo de origem pode se tornar: 

#include "add.h"

int triple(int x)
{
    return add(x, add(x,x));
}

Agora, cada vez que o código é compilado, os últimos protótipos de função em add.hserão incluídos nos arquivos que os utilizam, evitando erros potencialmente desastrosos.

Suporte de linguas

C / C ++

Em C e C ++ , a #include diretiva do pré - processador faz com que o compilador substitua essa linha por todo o texto do conteúdo do arquivo de origem nomeado (se incluído entre aspas: "") ou cabeçalho nomeado (se incluído entre colchetes angulares: <>); observe que um cabeçalho não precisa ser um arquivo de origem. A inclusão continua recursivamente nesses conteúdos incluídos, até um limite de aninhamento definido pela implementação. Os cabeçalhos não precisam ter nomes correspondentes aos arquivos: em C ++ os cabeçalhos padrão são normalmente identificados com palavras, como "vetor", portanto, #include <vector>enquanto em C os cabeçalhos padrão têm identificadores na forma de nomes de arquivos com uma extensão ".h", como em #include <stdio.h>. Um "arquivo de origem" pode ser qualquer arquivo, com um nome de qualquer forma, mas é mais comumente nomeado com uma extensão ".h" e chamado de "arquivo de cabeçalho" (às vezes ".hpp" ou ".hh" para distinguir C ++ cabeçalhos), embora arquivos com extensões .c, .cc e .cpp também possam ser incluídos (particularmente na técnica de unidade de compilação única ) e, às vezes, outras extensões são usadas.

Essas duas formas de #includediretiva podem determinar qual cabeçalho ou arquivo de origem incluir de uma forma definida pela implementação. Na prática, o que geralmente é feito é que o formulário de colchetes procura por arquivos de origem em um diretório de sistema padrão (ou conjunto de diretórios) e, em seguida, procura por arquivos de origem em caminhos locais ou específicos do projeto (especificados na linha de comando, em uma variável de ambiente, ou em um Makefile ou outro arquivo de construção), enquanto o formulário com aspas não pesquisa em um diretório de sistema padrão, apenas pesquisando em caminhos locais ou específicos do projeto. Caso não haja conflito, a forma de colchetes angulares também pode ser usada para especificar as inclusões específicas do projeto, mas isso é considerado uma forma inadequada. O fato de que os cabeçalhos não precisam corresponder aos arquivos é principalmente um tecnicismo de implementação e é usado para omitir a extensão .h ao incluir cabeçalhos padrão C ++; em uso comum, "cabeçalho" significa "arquivo de cabeçalho".

Por exemplo: 

#include <stdio.h>  // Include the contents of the standard header 'stdio.h' (probably a file 'stdio.h').
#include <vector>  // Include the contents of the standard header 'vector' (probably a file 'vector.h').
#include "user_defined.h"  // Include the contents of the file 'user_defined.h'.

Em C e C ++, podem ocorrer problemas se dois (ou mais) incluirem arquivos, ambos por sua vez incluirem o mesmo terceiro arquivo. Uma solução é evitar que os arquivos de inclusão incluam quaisquer outros arquivos, possivelmente exigindo que o programador adicione manualmente diretivas de inclusão extras ao arquivo original. Outra solução é incluir guardas .

COBOL

O COBOL (e também o RPG IV ) permite que os programadores copiem copybooks para o código-fonte do programa de maneira semelhante aos arquivos de cabeçalho, mas também permite a substituição de determinado texto neles por outro texto. A palavra-chave COBOL para inclusão é COPYe a substituição é feita usando a REPLACING ... BY ...cláusula. Uma diretiva de inclusão está presente no COBOL desde COBOL 60, mas mudou do original INCLUDEpara COPYem 1968.

Fortran

O Fortran não requer arquivos de cabeçalho por si só . No entanto, o Fortran 90 e posterior possui dois recursos relacionados: includeinstruções e módulos. O primeiro pode ser usado para compartilhar um arquivo comum contendo interfaces de procedimento, bem como um cabeçalho C, embora a especificação de uma interface não seja necessária para todas as variedades de procedimentos Fortran. Essa abordagem não é comumente usada; em vez disso, os procedimentos são geralmente agrupados em módulos que podem ser referenciados com uma useinstrução dentro de outras regiões do código. Para módulos, as informações de interface do tipo cabeçalho são geradas automaticamente pelo compilador e normalmente colocadas em arquivos de módulo separados, embora alguns compiladores tenham colocado essas informações diretamente em arquivos de objeto. A especificação da linguagem em si não exige a criação de nenhum arquivo extra, embora as interfaces de procedimento do módulo sejam propagadas quase universalmente dessa maneira.

Pascal

A maioria dos compiladores Pascal suporta a diretiva do compilador $iou $include, em que a diretiva $iou $includesegue imediatamente o início de um bloco de comentário na forma de

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

Onde a diretiva $iou $includenão faz distinção entre maiúsculas e minúsculas , e filename.pas ou filename.inc é o nome do arquivo a ser incluído. (Tem sido uma prática comum nomear arquivos de inclusão pascal com a extensão .inc, mas isso não é necessário.) Alguns compiladores, para evitar recursão crock , limitam a invocação de um arquivo de inclusão a um determinado número, proíbem invocar a si mesmo ou qualquer arquivo aberto atualmente, ou está limitado a um máximo de um arquivo de inclusão por vez, por exemplo, um arquivo de inclusão não pode incluir a si mesmo ou outro arquivo; no entanto, o programa que inclui outros arquivos pode incluir vários, apenas um de cada vez.

PHP

No PHP , a includediretiva faz com que outro arquivo PHP seja incluído e avaliado. Comandos semelhantes são require, que em caso de não inclusão produzirão uma exceção fatal e interromperão o script, e include_oncee require_once, que farão com que um arquivo não seja incluído ou solicitado novamente se já tiver sido incluído ou requerido, evitando o problema de dupla inclusão do C.

Outras línguas

Existem muitas formas de diretiva include, como:

Linguagens modernas (por exemplo, Haskell e Java ) tendem a evitar copybooks ou includes, preferindo módulos e sistemas de importação / exportação para controle de namespace . Algumas dessas linguagens (como Java e C # ) não usam declarações de encaminhamento e, em vez disso, os identificadores são reconhecidos automaticamente dos arquivos de origem e lidos diretamente dos símbolos da biblioteca dinâmica (normalmente referenciados com importou usingdiretivas), o que significa que os arquivos de cabeçalho não são necessários.

Veja também

Referências

links externos