Nas linguagens de programação C e C ++, qual é a diferença entre usar colchetes angulares e usar aspas em uma include
instrução, como segue?
#include <filename>
#include "filename"
c++
c
include
header-files
c-preprocessor
quest49
fonte
fonte
Respostas:
Na prática, a diferença está no local em que o pré-processador procura o arquivo incluído.
Para
#include <filename>
o pré-processador, procura de maneira dependente da implementação, normalmente em diretórios de pesquisa pré-designados pelo compilador / IDE. Este método é normalmente usado para incluir arquivos de cabeçalho de biblioteca padrão.Para
#include "filename"
as pesquisas pré-processador primeiros no mesmo diretório que o arquivo que contém a directiva, e, em seguida, segue o caminho de pesquisa usado para o#include <filename>
formulário. Este método é normalmente usado para incluir arquivos de cabeçalho definidos pelo programador.Uma descrição mais completa está disponível na documentação do GCC nos caminhos de pesquisa .
fonte
#include <...>
usei o pacote instalado no sistema e#include "..."
a versão do repositório nas proximidades. Eu posso ter isso ao contrário. De qualquer forma, a proteção de inclusão no cabeçalho empacotado é prefixada com um sublinhado. (Poderia ser uma convenção para pacotes ou talvez uma maneira de deliberadamente evitar a mistura dos dois, embora eliminatórias versão faria mais sentido para mim.)A única maneira de saber é ler a documentação da sua implementação.
Na norma C , a seção 6.10.2, os parágrafos 2 a 4 afirmam:
fonte
A sequência de caracteres entre <e> refere-se exclusivamente a um cabeçalho, que não é necessariamente um arquivo. As implementações são praticamente livres para usar a sequência de caracteres como desejarem. (Principalmente, no entanto, apenas trate-o como um nome de arquivo e faça uma pesquisa no caminho de inclusão , como as outras postagens afirmam.)
Se o
#include "file"
formulário for usado, a implementação procurará primeiro um arquivo com o nome especificado, se suportado. Se não (suportado), ou se a pesquisa falhar, a implementação se comportará como se o outro#include <file>
formulário ( ) tivesse sido usado.Além disso, um terceiro formulário existe e é usado quando a
#include
diretiva não corresponde a nenhum dos formulários acima. Nesta forma, algum pré-processamento básico (como expansão de macro) é realizado nos "operandos" da#include
diretiva e o resultado deve corresponder a uma das duas outras formas.fonte
<
e>
como a chave para indexar na biblioteca.Algumas boas respostas aqui fazem referências ao padrão C, mas esquecem o padrão POSIX, especialmente o comportamento específico do comando c99 (por exemplo, C compiler) .
De acordo com o The Open Group Base Specifications Issue 7 ,
Portanto, em um ambiente compatível com POSIX, com um compilador C compatível com POSIX,
#include "file.h"
provavelmente procurará./file.h
primeiro, onde.
é o diretório onde está o arquivo com a#include
instrução, enquanto#include <file.h>
provavelmente procurará/usr/include/file.h
primeiro, onde/usr/include
seu sistema está definido locais habituais para cabeçalhos (parece não ser definido pelo POSIX).fonte
c99
- que é o nome POSIX para o compilador C. (O padrão POSIX 2008 dificilmente poderia se referir a C11; a atualização 2013 para POSIX 2008 não alterou o padrão C que se referia a.)-L
.A documentação do GCC diz o seguinte sobre a diferença entre os dois:
fonte
Faz:
com
.
sendo o diretório do arquivo onde o#include
está contido, e / ou o diretório de trabalho atual do compilador, e / ou adefault_include_paths
e
Se
./
estiver<default_include_paths>
, então não faz diferença.Se
mypath/myfile
estiver em outro diretório de inclusão, o comportamento é indefinido.fonte
#include "mypath/myfile"
não é equivalente a#include "./mypath/myfile"
. Como a resposta do piCookie diz, aspas duplas dizem ao compilador para pesquisar de uma maneira definida pela implementação - o que inclui a pesquisa nos locais especificados#include <...>
. (Na verdade, é provavelmente equivalente, mas apenas porque, por exemplo,/usr/include/mypath/myfile
pode ser referida como/usr/include/./mypath/myfile
-., Pelo menos, em Unix como sistemas)defaultincludepaths
, em vez de atribuir outro significado ao.
(como mencionado acima). Isto tem a consequência esperada que tanto#include "..."
e#include <...>
pesquisar em dirpathA
<file>
inclusão diz ao pré-processador para procurar nos-I
diretórios e nos diretórios predefinidos primeiro , depois no diretório do arquivo .c. A"file"
inclusão diz ao pré-processador para procurar primeiro no diretório do arquivo de origem e depois reverter para-I
e predefinido. Todos os destinos são pesquisados de qualquer maneira, apenas a ordem da pesquisa é diferente.O padrão de 2011 discute principalmente os arquivos de inclusão em "16.2 Inclusão de arquivo de origem".
Observe que o
"xxx"
formulário é degradado para<xxx>
formar se o arquivo não for encontrado. O restante é definido pela implementação.fonte
-I
negócio está especificado?-I
.#include <file.h>
diz ao compilador para procurar o cabeçalho em seu diretório "inclui", por exemplo, para MinGW, o compilador procurariafile.h
em C: \ MinGW \ include \ ou onde quer que seu compilador esteja instalado.#include "file"
diz ao compilador para procurar o diretório atual (ou seja, o diretório em que o arquivo de origem reside)file
.Você pode usar o
-I
sinalizador para o GCC para informar que, quando encontrar uma inclusão com colchetes angulares, também deverá procurar cabeçalhos no diretório depois-I
. O GCC tratará o diretório após o sinalizador como se fosse oincludes
diretório.Por exemplo, se você tiver um arquivo chamado
myheader.h
em seu próprio diretório, poderá dizer#include <myheader.h>
se chamou o GCC com o sinalizador-I .
(indicando que ele deve procurar inclusões no diretório atual).Sem o
-I
sinalizador, você precisará usar#include "myheader.h"
para incluir o arquivo ou movermyheader.h
para oinclude
diretório do seu compilador.fonte
Pelo padrão - sim, eles são diferentes:
Observe que o padrão não informa nenhuma relação entre as maneiras definidas pela implementação. O primeiro formulário pesquisa de uma maneira definida pela implementação e o outro de uma maneira (possivelmente outra) definida pela implementação. A norma também especifica que certos arquivos de inclusão devem estar presentes (por exemplo,
<stdio.h>
).Formalmente, você teria que ler o manual do seu compilador; no entanto, normalmente (por tradição) o
#include "..."
formulário pesquisa o diretório do arquivo no qual o arquivo#include
foi encontrado primeiro e, em seguida, os diretórios#include <...>
pesquisados pelo formulário (o caminho de inclusão, por exemplo, cabeçalhos do sistema )fonte
Obrigado pelas ótimas respostas, esp. Adam Stelmaszczyk, piCookie e aib.
Como muitos programadores, usei a convenção informal de usar o
"myApp.hpp"
formulário para arquivos específicos de aplicativos e o<libHeader.hpp>
formulário para arquivos de sistema de biblioteca e compilador, ou seja, arquivos especificados em/I
eINCLUDE
variável de ambiente, por anos pensando que era o padrão.No entanto, o padrão C afirma que a ordem de pesquisa é específica da implementação, o que pode dificultar a portabilidade. Para piorar a situação, usamos jam, que descobre automaticamente onde estão os arquivos de inclusão. Você pode usar caminhos relativos ou absolutos para seus arquivos de inclusão. ie
As versões mais antigas do MSVS exigiam barras invertidas duplas (\\), mas agora isso não é necessário. Não sei quando isso mudou. Basta usar barras para compatibilidade com o 'nix (o Windows aceitará isso).
Se você estiver realmente preocupado com isso, use
"./myHeader.h"
para um arquivo de inclusão no mesmo diretório que o código-fonte (meu projeto atual, muito grande, possui alguns nomes de arquivo de inclusão duplicados espalhados - realmente um problema de gerenciamento de configuração).Aqui está a explicação do MSDN copiada aqui para sua conveniência).
fonte
Pelo menos para a versão GCC <= 3.0, o formulário entre colchetes não gera uma dependência entre o arquivo incluído e o arquivo incluído.
Portanto, se você deseja gerar regras de dependência (usando a opção GCC -M, por exemplo), use o formulário entre aspas para os arquivos que devem ser incluídos na árvore de dependência.
(Consulte http://gcc.gnu.org/onlinedocs/cpp/Invocation.html )
fonte
Para
#include ""
um compilador, normalmente pesquisa a pasta do arquivo que contém essa pasta e as outras pastas. Para#include <>
o compilador não pesquisa a pasta do arquivo atual.fonte
<filename>
e"filename"
procura por locais definidos pela implementação.Quando você usa #include <filename>, o pré-processador que procura o arquivo no diretório dos arquivos de cabeçalho C \ C ++ (stdio.h \ cstdio, string, vetor etc.). Mas, quando você usa #include "filename": primeiro, o pré-processador procura o arquivo no diretório atual e, se não estiver aqui - ele o procura no diretório dos arquivos de cabeçalho C \ C ++.
fonte
#include
diretiva não está estritamente relacionada a arquivos.Um #include com colchetes angulares pesquisará uma "lista de locais dependentes da implementação" (que é uma maneira muito complicada de dizer "cabeçalhos do sistema") para que o arquivo seja incluído.
Um #include com aspas procurará apenas um arquivo (e, "de uma maneira dependente da implementação", bleh). O que significa que, em inglês normal, ele tentará aplicar o caminho / nome do arquivo que você lança nele e não precederá um caminho do sistema ou o violará de outra forma.
Além disso, se #include "" falhar, é relido como #include <> pelo padrão.
A documentação do gcc tem uma descrição (específica do compilador) que, embora seja específica do gcc e não do padrão, é muito mais fácil de entender do que a conversa do advogado sobre os padrões ISO.
fonte
zlib.h
nos meus caminhos de pesquisa de 'usuário' e existe uma versão diferente no caminho de pesquisa do sistema, então#include <zlib.h>
inclui a versão do sistema e a#include "zlib.h"
minha?Exemplo:
O nome do arquivo aqui é
Seller.h
:Na implementação da classe (por exemplo,
Seller.cpp
e em outros arquivos que usarão o arquivoSeller.h
), o cabeçalho definido pelo usuário agora deve ser incluído, da seguinte maneira:fonte
#include <>
é para arquivos de cabeçalho predefinidosSe o arquivo de cabeçalho for predefinido, você simplesmente escreveria o nome do arquivo de cabeçalho entre parênteses angulares e ficaria assim (supondo que tenhamos um nome de arquivo de cabeçalho predefinido iostream):
#include " "
é para arquivos de cabeçalho que o programador defineSe você (o programador) escreveu seu próprio arquivo de cabeçalho, você deve escrever o nome do arquivo de aspas entre aspas. Portanto, suponha que você tenha escrito um arquivo de cabeçalho chamado
myfile.h
, este é um exemplo de como você usaria a diretiva de inclusão para incluir esse arquivo:fonte
Muitas das respostas aqui se concentram nos caminhos que o compilador pesquisará para encontrar o arquivo. Enquanto isso é o que a maioria dos compiladores faz, é permitido que um compilador em conformidade seja pré-programado com os efeitos dos cabeçalhos padrão e trate, digamos,
#include <list>
como uma opção, e ele não precisa existir como um arquivo.Isto não é puramente hipotético. Há pelo menos um compilador que funciona dessa maneira.
#include <xxx>
É recomendado o uso apenas com cabeçalhos padrão.fonte
é usado para incluir arquivos de biblioteca padrão. Portanto, o compilador verificará os locais onde residem os cabeçalhos da biblioteca padrão.
dirá ao compilador para incluir arquivos de cabeçalho definidos pelo usuário. Portanto, o compilador verificará esses arquivos de cabeçalho na pasta atual ou nas
-I
pastas definidas.fonte
No C ++, inclua um arquivo de duas maneiras:
O primeiro é #include, que informa ao pré-processador para procurar o arquivo no local padrão predefinido. Esse local geralmente é uma variável de ambiente INCLUDE que indica o caminho para incluir arquivos.
E o segundo tipo é #include "filename", que informa ao pré-processador para procurar o arquivo no diretório atual primeiro e depois nos locais predefinidos que o usuário configurou.
fonte
Formulário 1 - #include <xxx>
Primeiro, procura a presença do arquivo de cabeçalho no diretório atual de onde a diretiva é chamada. Se não for encontrado, ele procurará na lista pré-configurada de diretórios padrão do sistema.
Formulário 2 - #include "xxx"
Isso procura a presença do arquivo de cabeçalho no diretório atual de onde a diretiva é chamada.
A lista exata de diretórios de pesquisa depende do sistema de destino, de como o GCC está configurado e de onde está instalado. Você pode encontrar a lista de diretórios de pesquisa do seu compilador GCC executando-a com a opção -v.
Você pode adicionar diretórios adicionais ao caminho de pesquisa usando - I dir , o que faz com que o diretório seja pesquisado após o diretório atual (para a forma de cotação da diretiva) e antes dos diretórios padrão do sistema.
Basicamente, o formato "xxx" nada mais é do que pesquisar no diretório atual; se não for encontrado caindo de volta o formulário
fonte
#include "header.h"
formulário não é precisa, @personal_cloud. Considero a resposta de piCookie e Yann Droneaud a mais relevante, pois identificam de onde vêm as informações. Também não acho que a resposta mais votada seja totalmente satisfatória.A
#include <filename>
é usado quando um arquivo de sistema está a ser referido. Esse é um arquivo de cabeçalho que pode ser encontrado em locais padrão do sistema, como/usr/include
ou/usr/local/include
. Para seus próprios arquivos que precisam ser incluídos em outro programa, você deve usar a#include "filename"
sintaxe.fonte
Idealmente, você usaria <...> para bibliotecas C padrão e "..." para bibliotecas que você escreve e está presente no diretório atual.
fonte
A regra geral simples é usar colchetes angulares para incluir arquivos de cabeçalho que acompanham o compilador. Use aspas duplas para incluir outros arquivos de cabeçalho. A maioria dos compiladores faz dessa maneira.
1.9 - Os arquivos de cabeçalho explicam com mais detalhes as diretrizes do pré-processador. Se você é um programador iniciante, essa página deve ajudá-lo a entender tudo isso. Eu aprendi a partir daqui, e tenho seguido no trabalho.
fonte
#include <filename>
é usado quando você deseja usar o arquivo de cabeçalho do sistema C / C ++ ou das bibliotecas do compilador. Essas bibliotecas podem ser stdio.h, string.h, math.h, etc.
#include "path-to-file/filename"
é usado quando você deseja usar seu próprio arquivo de cabeçalho personalizado, que está na pasta do projeto ou em outro lugar.
Para mais informações sobre pré-processadores e cabeçalho. Leia C - Pré-processadores .
fonte
#include <filename>
#include "filename"
#include <filename>
e procura o arquivo de cabeçalho no local onde os arquivos de cabeçalho do sistema estão armazenados.#include <filename>
.fonte
Para ver a ordem de pesquisa em seu sistema usando o gcc, com base na configuração atual, você pode executar o seguinte comando. Você pode encontrar mais detalhes sobre este comando aqui
cpp -v /dev/null -o /dev/null
fonte
Inclui um arquivo em que o diretório de inclusão padrão é.
Inclui um arquivo no diretório atual em que foi compilado.
fonte
Existem duas maneiras de escrever a instrução #include.
O significado de cada formulário é
Este comando procuraria o arquivo
mylib.h
no diretório atual, bem como a lista especificada de diretórios, conforme mencionado no caminho de pesquisa de inclusão que pode ter sido configurado.Este comando procuraria o arquivo apenas
mylib.h
na lista especificada de diretórios.O caminho de pesquisa de inclusão não passa de uma lista de diretórios que seriam pesquisados pelo arquivo que está sendo incluído. Os compiladores C diferentes permitem definir o caminho de pesquisa de maneiras diferentes.
fonte