Quelle est la différence entre #include et #include "filename"?

dans les langages de programmation C et C++, Quelle est la différence entre l'utilisation de crochets d'angle et l'utilisation de guillemets dans une instruction include , comme suit?

  1. #include <filename>
  2. #include "filename"
1861
demandé sur Anthon 2008-08-22 05:40:06
la source

30 ответов

en pratique, la différence réside dans l'endroit où le préprocesseur recherche le fichier inclus.

pour #include <filename> le préprocesseur recherche de manière dépendante de l'implémentation, normalement dans des répertoires de recherche pré-désignés par le compilateur/IDE. Cette méthode est normalement utilisée pour inclure les fichiers d'en-tête de bibliothèque standard.

Pour #include "filename" le préprocesseur recherche tout d'abord dans le même répertoire que le fichier contenant les le moteur de recherche #include <filename> . Cette méthode est normalement utilisée pour inclure des fichiers d'en-tête définis par le programmeur.

une description plus complète est disponible dans le GCC documentation sur les chemins de recherche .

1074
répondu quest49 2018-01-16 19:12:29
la source

la seule façon de le savoir est de lire la documentation de votre implémentation.

Dans la norme , l'article 6.10.2, paragraphes 2 à 4 de l'état:

  • une directive de prétraitement du formulaire

    #include <h-char-sequence> new-line
    

    recherche une séquence d'endroits définis par la mise en œuvre pour un en-tête identifié uniquement par la séquence spécifiée entre le < et > délimiteurs, et provoque le remplacement de cette directive par le contenu entier de l'en-tête. Comment les endroits sont spécifiés ou l'en-tête identifié est implémentation-défini.

  • une directive de prétraitement du formulaire

    #include "q-char-sequence" new-line
    

    provoque le remplacement de cette directive par la totalité du contenu du fichier source identifié par la séquence spécifiée entre les délimiteurs " . Le fichier source nommé est recherché d'une manière définie par la mise en œuvre. Si cette recherche n'est pas prise en charge, ou si la recherche échoue, la directive est retraitée comme si elle se lisait

    #include <h-char-sequence> new-line
    

    avec la séquence contenue identique (y compris les caractères > , le cas échéant) de l'original directive.

  • une directive de prétraitement du formulaire

    #include pp-tokens new-line
    

    (qui ne la correspondance avec l'un des deux formulaires précédents est permise. Les jetons de prétraitement après include dans la directive sont traités comme dans le texte normal. (Chaque identifiant actuellement défini comme un nom macro est remplacé par sa liste de remplacement des tokens de prétraitement.) La directive résultant de tous les remplacements doit correspondre à l'un des deux formulaires précédents. La méthode par laquelle une séquence de prétraitement des jetons entre un < et un > prétraitement jeton paire, ou une paire de Les caractères " sont combinés en un nom d'en-tête unique.

Définitions:

  • h-char: tout élément du jeu de caractères source, sauf le caractère de nouvelle ligne et >

  • q-char: tout élément du jeu de caractères source à l'exception du caractère new-line et "

603
répondu piCookie 2016-08-22 12:22:31
la source

la séquence de caractères entre < et > renvoie uniquement à un en-tête, qui n'est pas nécessairement un fichier. Les implémentations sont assez libres d'utiliser la séquence de caractères comme elles le souhaitent. (La plupart du temps, cependant , il suffit de le traiter comme un nom de fichier et de faire une recherche dans le include path , comme l'indiquent les autres messages.)

si le formulaire #include "file" est utilisé, l'implémentation recherche d'abord un fichier du prénom, s'il est supporté. Si non (pris en charge), ou si la recherche échoue, l'implémentation se comporte comme si l'autre forme ( #include <file> ) était utilisée.

de plus, un troisième formulaire existe et est utilisé lorsque la directive #include ne correspond à aucun des formulaires ci-dessus. Sous cette forme, un prétraitement de base (tel que l'expansion macro) est effectué sur les "opérandes" de la directive #include , et le résultat devrait correspondre à l'une des deux autres formes.

229
répondu aib 2013-04-22 20:06:58
la source

quelques bonnes réponses font ici référence à la norme C mais ont oublié la norme POSIX, en particulier le comportement spécifique de la commande c99 (e.g. compilateur C) .

Selon Le Groupe de la Base de Spécifications Numéro 7 ,

- I répertoire

modifier l'algorithme de recherche pour en-têtes dont les noms ne sont pas des noms de chemin absolus à regarder dans le répertoire nommé par le répertoire nom de chemin avant de regarder dans les endroits habituels. Ainsi, les en-têtes dont le nom est entouré de guillemets ( "" ) doivent être recherchés d'abord dans le répertoire du fichier avec les options #include , puis dans les répertoires nommés dans -I , et dernier aux endroits habituels. Pour les en-têtes dont les noms sont placés entre crochets ( "<>"), l'en-tête ne doit être recherché que dans les répertoires nommés dans les options - I et ensuite dans les endroits habituels. Les répertoires nommés dans les options - I doivent être recherchés dans l'ordre spécifié. Les implémentations doivent supporter au moins dix instances de cette option dans une seule invocation de commande c99 .

ainsi, dans un environnement conforme à POSIX, avec un compilateur C conforme à POSIX, #include "file.h" va probablement chercher pour ./file.h d'abord, où . est le répertoire où est le fichier avec l'énoncé #include , tandis que #include <file.h> , va probablement chercher pour /usr/include/file.h d'abord, où /usr/include est votre système défini endroits habituels pour les en-têtes (il semble pas défini par POSIX).

94
répondu Yann Droneaud 2015-03-12 08:29:33
la source

il fait:

"mypath/myfile" is short for ./mypath/myfile

avec . étant soit le répertoire du fichier dans lequel #include est contenu, et/ou le répertoire courant du compilateur, et / ou le default_include_paths

et

<mypath/myfile> is short for <defaultincludepaths>/mypath/myfile

si ./ est dans <default_include_paths> , alors ça ne fait pas de différence.

si mypath/myfile est dans un autre répertoire d'include, le comportement n'est pas défini.

38
répondu Stefan Steiger 2016-09-06 12:04:29
la source

la documentation de GCC dit ce qui suit au sujet de la différence entre les deux:

les fichiers d'en-tête d'utilisateur et de système sont inclus en utilisant la directive prétraitement ‘#include’ . Il a deux variantes:

#include <file>

cette variante est utilisée pour les fichiers d'en-tête du système. Il recherche un fichier nommé fichier dans une liste standard des répertoires système. Vous pouvez ajouter des répertoires à cette liste avec l'option -I (voir Invocation ).

#include "file"

Cette variante est utilisée pour les fichiers d'en-tête de votre propre programme. Il recherche un fichier nommé premier fichier dans le répertoire contenant le fichier courant, puis dans le devis répertoires et puis la même répertoires utilisés pour <file> . Vous pouvez ajouter des répertoires à la liste des répertoires de devis avec l'option -iquote . L'argument de ‘#include’ , qu'il soit délimité par des guillemets ou des crochets d'angle, se comporte comme une constante de chaîne en ce que les commentaires ne sont pas reconnus, et les noms de macro ne sont pas développés. Ainsi, #include <x/*y> spécifie l'inclusion d'un fichier d'en-tête de système nommé x/*y .

cependant, si les antislashs se produisent dans le fichier, ils sont considéré comme des caractères de texte ordinaire, pas des caractères d'évasion. Aucune des séquences d'échappement de caractères appropriées aux constantes de chaîne en C n'est traitée. Ainsi, #include "x\n\y" spécifie un nom de fichier contenant trois antislashs. (Certains systèmes interprètent ' \ ' comme un séparateur de chemin. Tous ces éléments interprètent également ‘/’ de la même façon. Il est le plus portable pour utiliser seulement ‘/’ .)

c'est une erreur s'il y a quelque chose (autre que des commentaires) sur la ligne après le nom de fichier.

34
répondu Suraj Jain 2017-11-22 00:51:16
la source

le <file> include indique au préprocesseur de rechercher dans les répertoires -I et dans les répertoires prédéfinis d'abord , puis dans le .c du répertoire du fichier. L'include "file" indique au préprocesseur de rechercher dans le répertoire du fichier source d'abord , puis de revenir à -I et prédéfinie. Toutes les destinations sont recherchées de toute façon, seul l'ordre de recherche est différent.

la norme 2011 traite principalement des fichiers include dans "16.2 inclusion du fichier Source".

2 une directive de prétraitement du formulaire

# include <h-char-sequence> new-line

recherche une séquence d'endroits définis par la mise en œuvre pour un en-tête identifié uniquement par le séquence spécifiée entre les délimiteurs < et >, et provoque la remplacement de cette directive par l'ensemble du contenu de l'en-tête. Comment les endroits sont spécifiés ou l'en-tête est identifié la mise en œuvre définies.

3 une directive de prétraitement du formulaire

# include "q-char-sequence" new-line

provoque le remplacement de cette directive par l'ensemble du contenu du fichier source identifié par le séquence spécifiée entre les " séparateurs. Le fichier source nommé est recherché pour la mise en œuvre définis. Si cette recherche est pas pris en charge, ou si la recherche échoue, la directive est retraité comme si elle se lit

# include <h-char-sequence> new-line

avec la séquence contenue identique (y compris > caractères, le cas échéant) de la directive originale.

notez que la forme "xxx" se dégrade en forme <xxx> si le fichier n'est pas trouvé. Le reste est défini par la mise en œuvre.

25
répondu Arkadiy 2014-12-28 21:25:27
la source

Par la norme - oui, ils sont différents:

  • une directive de prétraitement du formulaire

    #include <h-char-sequence> new-line
    

    recherche une séquence d'endroits définis par la mise en œuvre pour un en-tête identifié uniquement par la séquence spécifiée entre les délimiteurs < et > , et provoque le remplacement de cette directive par le contenu entier de l'en-tête. Comment les endroits sont spécifiés ou l'en-tête identifié est implémentation-defined.

  • une directive de prétraitement du formulaire

    #include "q-char-sequence" new-line
    

    provoque le remplacement de cette directive par la totalité du contenu du fichier source identifié par la séquence spécifiée entre les délimiteurs " . Le fichier source nommé est recherché d'une manière définie par la mise en œuvre. Si cette recherche n'est pas pris en charge, ou si la recherche échoue, l' la directive est retraitée comme si elle se lisait

    #include <h-char-sequence> new-line
    

    avec la séquence contenue identique (y compris les caractères > , le cas échéant) de l'original directive.

  • une directive de prétraitement du formulaire

    #include pp-tokens new-line
    

    (qui ne correspond pas à l'un des deux formulaires précédents) est autorisé. Les jetons de prétraitement après include dans la directive sont traités comme dans texte normal. (Chaque identifiant actuellement défini comme un nom macro est remplacé par sa liste de remplacement des tokens de prétraitement.) La directive résultant de tous les remplacements doit correspondre à l'un des deux formulaires précédents. La méthode par laquelle une séquence de jetons de prétraitement entre un < et un > paire de jetons de prétraitement ou une paire de " caractères est combinée en un nom d'en-tête unique jeton de prétraitement est mise en œuvre-définie.

Définitions:

  • h-char: tout élément du jeu de caractères source, sauf le caractère de nouvelle ligne et >

  • q-char: tout élément du jeu de caractères source à l'exception du caractère de nouvelle ligne et "

noter que la norme ne dit pas de relation entre le la mise en œuvre définies par les mœurs. Le premier formulaire recherche d'une manière définie par la mise en œuvre, et l'autre d'une manière (éventuellement autre) définie par la mise en œuvre. La norme spécifie également que certains fichiers include doivent être présents (par exemple, <stdio.h> ).

officiellement, vous auriez à lire le manuel de votre compilateur, cependant normalement (par tradition) le formulaire #include "..." recherche le répertoire du fichier dans lequel le #include a été trouvé en premier, et puis le répertoires que le #include <...> forme des recherches (le chemin d'inclusion, par exemple des en-têtes de système).

17
répondu skyking 2016-07-28 10:25:35
la source

au moins pour la version GCC <= 3.0, la forme de support d'angle ne génère pas de dépendance entre le fichier inclus et le fichier inclus.

donc si vous voulez générer des règles de dépendances (en utilisant L'option GCC-M par exemple), vous devez utiliser le formulaire cité pour les fichiers qui doivent être inclus dans l'arbre de dépendances.

(voir ) http://gcc.gnu.org/onlinedocs/cpp/Invocation.html )

12
répondu Denis Ros 2011-10-25 16:35:25
la source

Merci pour les réponses grands, esp. Adam Stelmaszczyk et piCookie, et de l'aib.

comme beaucoup de programmeurs, j'ai utilisé la convention informelle d'utiliser le formulaire "myApp.hpp" pour les fichiers spécifiques à une application, et le formulaire <libHeader.hpp> pour les fichiers de bibliothèques et de systèmes de compilateurs, c'est-à-dire les fichiers spécifiés dans /I et la variable d'environnement INCLUDE , pendant des années pensant que c'était la norme.

Cependant, le C standard unis que l'ordre de recherche est spécifique à la mise en œuvre, ce qui peut compliquer la portabilité. Pour empirer les choses, nous utilisons jam, qui calcule automatiquement où sont les fichiers include. Vous pouvez utiliser des chemins relatifs ou absolus pour vos fichiers à inclure. c'est à dire

#include "../../MyProgDir/SourceDir1/someFile.hpp"

anciennes versions de MSVS requis double backslashes ( \ \ ), mais maintenant ce n'est pas nécessaire. Je ne sais pas quand ça a changé. Il suffit d'utiliser forward slashes pour la compatibilité avec 'nix (Windows l'acceptera).

si vous êtes vraiment inquiet à ce sujet, utilisez "./myHeader.h" pour un fichier include dans le même répertoire que le code source (mon projet actuel, très grand a quelques noms de fichiers include dispersés sur--vraiment un problème de gestion de configuration).

Voici la MSDN explication copié ici pour plus de commodité).

forme Citée

le préprocesseur recherche les fichiers include dans cet ordre:

  1. Dans le même répertoire que le fichier qui contient l'instruction #include.
  2. dans les répertoires des fichiers include actuellement ouverts, dans l'ordre inverse où

    ils ont été ouverts. La recherche commence dans le répertoire du Fichier parent include et

    continue vers le haut à travers les répertoires de tous les fichiers grandparent include.
  3. le long du chemin qui est spécifié par chaque option de compilateur /I .
  4. le long des trajectoires spécifiées par la variable d'environnement INCLUDE .

forme de support D'Angle

le préprocesseur recherche les fichiers include dans cet ordre:

  1. le long du chemin qui est spécifié par chaque option de compilateur /I .
  2. lors de la compilation se produit sur la ligne de commande, le long des chemins qui sont spécifiés par la variable d'environnement INCLUDE .
12
répondu riderBill 2016-11-10 07:08:06
la source

pour #include "" un compilateur recherche normalement le dossier du fichier qui contient ce include puis les autres dossiers. Pour #include <> le compilateur ne fait pas de recherche dans le dossier du fichier courant.

11
répondu Maxim Egorushkin 2015-07-25 18:29:19
la source
  • #include <> est pour les fichiers d'en-tête prédéfinis

si le fichier d'en-tête est prédéfini, alors vous écrirez simplement le nom du fichier d'en-tête entre parenthèses angulaires, et il ressemblera à ceci (en supposant que nous avons un nom de fichier d'en-tête prédéfini iostream):

#include <iostream>
  • #include " " est pour les fichiers d'en-tête le programmeur définit

si vous (le programmeur) avez écrit votre propre fichier d'en-tête, alors vous écririez le nom du fichier d'en-tête entre guillemets. Donc, supposons que vous ayez écrit un fichier d'en-tête appelé myfile.h , voici un exemple de la façon dont vous utiliseriez la directive include pour inclure ce fichier:

#include "myfile.h"
10
répondu MobiDev 2018-03-06 22:22:43
la source

#include <file.h> dit au compilateur de rechercher l'en-tête dans son répertoire "includes", p.ex. pour MinGW le compilateur chercherait file.h dans C:\MinGW\include\ ou là où votre compilateur est installé.

#include "file" dit au compilateur de rechercher dans le répertoire courant (c'est-à-dire le répertoire dans lequel le fichier source se trouve) file .

vous pouvez utiliser le drapeau -I pour que GCC lui dise que, quand il rencontre une include avec des crochets angulés, il devrait également rechercher des en-têtes dans le répertoire après -I . GCC traitera le répertoire après le drapeau comme s'il s'agissait du répertoire includes .

par exemple, si vous avez un fichier appelé myheader.h dans votre propre répertoire, vous pouvez dire #include <myheader.h> si vous avez appelé GCC avec le drapeau -I . (indiquant qu'il doit rechercher des includes dans le répertoire courant.)

sans la -I drapeau, vous devrez utiliser #include "myheader.h" pour inclure le fichier, ou déplacer myheader.h à la include répertoire de votre compilation.

9
répondu Adrian Zhang 2018-09-15 07:50:40
la source

un #include avec des crochets d'angle recherchera une" liste de lieux dépendant de l'implémentation "(ce qui est une façon très compliquée de dire" en-têtes système") pour que le fichier soit inclus.

un #include avec des guillemets ne fera que rechercher un fichier (et," d'une manière dépendante de l'implémentation", bleh). Ce qui signifie, en anglais normal, qu'il va essayer d'appliquer le chemin/nom de fichier que vous lancez sur elle et ne sera pas préparer un chemin système ou trafiquer avec elle autrement.

Aussi, si #include "" échoue, il est re-lire #include <> par la norme.

la documentation gcc a une description (propre au compilateur) qui, bien que spécifique au gcc et non à la norme, est beaucoup plus facile à comprendre que l'exposé de style avocat des normes ISO.

8
répondu Damon 2011-02-08 15:02:32
la source

Beaucoup de réponses ici l'accent sur les chemins, le compilateur recherche pour trouver le fichier. Alors que c'est ce que font la plupart des compilateurs, un compilateur conforme est autorisé à être préprogrammé avec les effets des en-têtes standard, et de traiter, disons, #include <list> comme un commutateur, et il n'a pas besoin d'exister en tant que fichier du tout.

Ce n'est pas purement hypothétique. Il y a au moins un compilateur qui fonctionne de cette façon. L'utilisation de #include <xxx> uniquement avec des en-têtes standard est recommandé.

7
répondu sp2danny 2017-05-30 13:19:46
la source
#include "filename" // User defined header
#include <filename> // Standard library header.

exemple:

le nom du fichier est Seller.h :

#ifndef SELLER_H     // Header guard
#define SELLER_H     // Header guard

#include <string>
#include <iostream>
#include <iomanip>

class Seller
{
    private:
        char name[31];
        double sales_total;

    public:
        Seller();
        Seller(char[], double);
        char*getName();

#endif

Dans l'implémentation de la classe (par exemple, Seller.cpp , et dans d'autres fichiers à utiliser le fichier Seller.h ), l'en-tête défini par l'utilisateur doit maintenant être inclus, comme suit:

#include "Seller.h"
7
répondu Barbara 2017-11-22 00:47:44
la source

lorsque vous utilisez # include , le pré-processeur recherchant le fichier dans directtory des fichiers d'en-tête C\C++ (stdio.h\cstdio, string, vector, etc.). Mais, quand vous utilisez #include "filename": tout d'abord, le pré-processeur cherche le fichier dans le répertoire courant, et s'il ne le fait pas ici - il le cherche dans le répertoire des fichiers d'en-tête C\C++.

7
répondu Chayim Friedman 2018-04-12 09:36:36
la source
#include <abc.h>

est utilisé pour inclure les fichiers de bibliothèque standard. Ainsi le compilateur vérifiera les endroits où résident les en-têtes de bibliothèque standard.

#include "xyz.h"

va dire au compilateur d'inclure définis par l'utilisateur fichiers d'en-tête. Ainsi, le compilateur vérifiera ces fichiers d'en-tête dans le dossier courant ou dans les dossiers définis -I .

6
répondu Christy Wald 2017-11-22 00:53:33
la source

En C++, et d'inclure un fichier de deux façons:

le premier est #include qui dit au préprocesseur de rechercher le fichier dans l'emplacement par défaut prédéfini. Cet emplacement est souvent une variable D'environnement INCLUDE qui indique le chemin vers les fichiers include.

et le second type est # include "filename" qui dit au préprocesseur de chercher le fichier dans le répertoire courant d'abord, puis le chercher dans les emplacements prédéfinis que l'Utilisateur a défini jusqu'.

5
répondu virat 2016-07-10 03:44:00
la source

"< nom de fichier > " recherches en bibliothèque standard C des lieux

alors que" nom de fichier " Recherche aussi dans le répertoire courant.

Idéalement, vous utiliseriez <...> pour les bibliothèques standard C et "..."pour les bibliothèques que vous écrivez, et sont présents dans le répertoire courant.

5
répondu jigar karangiya 2018-03-28 14:35:39
la source

le #include <filename> est utilisé lorsqu'il est fait référence à un fichier système. C'est un fichier d'en-tête qui peut être trouvé aux endroits par défaut du système comme /usr/include ou /usr/local/include . Pour vos propres fichiers qui doivent être inclus dans un autre programme, vous devez utiliser la syntaxe #include "filename" .

4
répondu srsci 2014-08-27 23:36:49
la source

Le plus simple est d'utiliser les chevrons pour inclure les fichiers d'en-tête qui viennent avec le compilateur. L'utilisation des guillemets pour inclure d'autres fichiers d'en-tête. La plupart des compilateurs le font de cette façon.

1.9 - Header files explique plus en détail les directives pré-processeur. Si vous êtes un programmeur novice, cette page devrait vous aider à comprendre tout cela. Je l'ai appris d'ici, et je l'ai suivi au travail.

3
répondu Eakan Gopalakrishnan 2016-01-01 23:33:49
la source
#include <filename>

est utilisé lorsque vous souhaitez utiliser le fichier d'en-tête C/C++ ou le compilateur bibliothèques. Ces bibliothèques peuvent être stdio.h, string.h, math.h, etc.

#include "path-to-file/filename"

est utilisé lorsque vous voulez utiliser votre propre fichier d'en-tête personnalisé qui se trouve dans votre dossier de projet ou ailleurs.

Pour plus d'informations sur les préprocesseurs et en-tête. Lire C - Préprocesseurs .

2
répondu Hafiz Shehbaz Ali 2016-08-23 13:38:29
la source

Formulaire 1- # inclure "xxx"

cherche D'abord la présence du fichier d'en-tête dans le répertoire courant à partir duquel la directive est invoquée. Si elle n'est pas trouvée, elle recherche dans la liste préconfigurée des répertoires système standard.

Formule 2- # inclure < xxx >

recherche la présence du fichier d'en-tête dans le répertoire courant à partir duquel la directive est invoquée.


le la liste exacte des répertoires de recherche dépend du système cible, de la façon dont GCC est configuré et de l'endroit où il est installé. Vous pouvez trouver l'annuaire de recherche liste de votre compilateur GCC en l'exécutant avec l'option-v.

vous pouvez ajouter des répertoires supplémentaires au chemin de recherche en utilisant - I dir , ce qui provoque dir pour être recherché après le répertoire courant (pour la forme de citation de la directive) et avant les répertoires système standard.


en gros, le formulaire "xxx" n'est rien d'autre que la recherche dans le répertoire courant; si vous ne le trouvez pas, retournez le formulaire

1
répondu Darshan L 2018-08-17 12:59:40
la source
  #include <filename>   (1)     
  #include "filename"   (2)

#include inclut le fichier source, identifié par un nom de fichier, dans le courant de la source du fichier à la ligne immédiatement après la directive.

la première version de la directive searchs only standard inclure annuaire. La bibliothèque standard C++, ainsi que la bibliothèque standard C, est implicitement inclus dans la norme inclure des répertoires. Norme les répertoires include peuvent être contrôlés par l'utilisateur par le compilateur option.

la deuxième version recherche d'abord le répertoire où le fichier courant réside et, seulement si le fichier n'est pas trouvé, recherche la norme inclure des répertoires.

Dans le cas où le fichier n'est pas trouvé, le programme est mal formé.

0
répondu S. M. AMRAN 2017-01-07 07:39:50
la source

Il existe deux façons d'écrire #include.Ce sont:

#include"filename"
#include<filename>

la signification de chaque forme est

#include"mylib.h"

cette commande recherchera le fichier mylib.h dans le répertoire courant ainsi que la liste spécifiée des répertoires comme indiqué dans le chemin de recherche include qui pourrait avoir été mis en place.

#include<mylib.h>

cette commande chercherait le fichier mylib.h dans la liste spécifiée de répertoires seulement.

le chemin de recherche include n'est rien d'autre qu'une liste de répertoires qui seraient recherchés pour le fichier inclus.Différents compilateurs C vous permettent de définir le chemin de recherche de différentes manières.

0
répondu Noshiii 2018-08-18 12:24:23
la source

pour voir l'ordre de recherche sur votre système utilisant gcc, basé sur la configuration actuelle , vous pouvez exécuter la commande suivante. Vous pouvez trouver plus de détails sur cette commande ici

cpp -v /dev/null -o /dev/null

Apple LLVM version 10.0.0 (clang-1000.10.44.2)

Cible: x86_64-apple-darwin18.0.0

Modèle de Thread: posix InstalledDir: Bibliothèque / développeur / CommandLineTools / usr / bin

"/Library/Developer/CommandLineTools/usr/bin / clang" - cc1-triple x86_64-apple-macosx10.14.0-Wdeprecated-objc-isa-usage -Werror=obsolète-objc-isa-utilisation-E -disable-gratuit -disable-llvm-verifier-jetez-valeur-noms -principal-nom de fichier null -mrelocation-modèle pic-pic-niveau 2 -mthread-modèle posix -mdisable-fp-elim -fno-strict-retour-masm-verbose-munwind-tableaux-cibles-processeur penryn -nain-colonne-info -débogueur de réglage=lldb -la cible de l'éditeur de liens-version 409.12 -v -ressources-dir /Bibliothèque/Développeur/CommandLineTools/usr/lib/clang/10.0.0 -isysroot /Library/Developer/CommandLineTools/SDKs / MacOSX10.14.SDK -I/usr/local / include-fdebug-compilation-dir / Users/hogstrom-ferror-limit 19-fmessage-length 80-stack-protector 1-fblocks -fencode-extended-block-signature-fobjc-runtime=macosx-10.14.0-fmax-type-align=16-fdiagnostics-show-option -fcolor-diagnostics -traditional-cpp -o - - x c /dev/null
1519100920" clang -ce1 version 10.0.0 (clang-1000.10.44.2) cible par défaut x86_64-apple-darwin18.0.0 ignorant non existing directory " /Library/Developer/CommandLineTools/SDKs / MacOSX10.14.sdk / usr / local / include" ignorant inexistant le répertoire "/Bibliothèque/Développeur/CommandLineTools/SDKs/MacOSX10.14.sdk / Library / Frameworks"

#include"..."la recherche commence ici:

#include <...> la recherche commence ici:

/usr/local/include

/Bibliothèque/Développeur/CommandLineTools/usr/lib/clang/10.0.0/include

/Bibliothèque/Développeur/CommandLineTools/usr/include

/Bibliothèque/Développeur/CommandLineTools/SDKs/MacOSX10.14.sdk/usr / include

/Library/Developer/CommandLineTools/SDKs / MacOSX10.14.sdk/System/Library/Frameworks (répertoire)

La fin de la liste de recherche.

0
répondu Hogstrom 2018-10-03 21:51:45
la source

je crois que les en-têtes inclus dans les guillemets seront recherchés dans les mêmes chemins de système que les inclusions entre crochets s'ils ne se trouvent pas dans le répertoire courant.

-1
répondu mellis 2008-09-02 02:19:04
la source

#include <filename>

trouvera le fichier correspondant dans la bibliothèque C++. cela signifie que si vous avez un fichier nommé bonjour.h dans le dossier de la bibliothèque C++, #include <hello.h> le chargera.

Mais,

#include "filename"

trouvera le fichier dans le même répertoire que celui où se trouve votre fichier source.

en outre,

#include "path_to_file/filename"

trouvera le fichier dans le répertoire où vous avez tapé dans path_to_file .

-1
répondu fractalwrench 2016-05-21 13:14:37
la source

l'ordre des fichiers d'en-tête de recherche est différent. < XXX.h > préfèrent rechercher les en-têtes standard tout d'abord tandis que " XXX.h " recherche d'abord les fichiers d'en-tête de l'espace de travail.

-2
répondu Ezio 2016-01-01 23:35:01
la source

Autres questions sur c++ c header-files c-preprocessor include