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

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 .

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 "

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.

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).

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.

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.

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.

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).

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 )

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 .

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.

• #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"

#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.

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.

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é.

#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"

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++.

#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 .

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'.

"< 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.

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" .

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.

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.

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 .

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

  #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é.

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.

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.

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.

#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 .

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.