В чем разница между #include & lt; filename & gt; и #include & quot; имя файла & quot ;?

В языках программирования C и C ++, в чем разница между использованием угловых скобок и использованием кавычек в операторе include, следующим образом?

  1. #include
  2. #include "filename"
вопрос задан 22.08.2008
quest49
20432 репутация

30 ответов


  • 0 рейтинг
    #include

    используется, когда вы хотите использовать заголовочный файл системы C / C ++ или библиотеки компилятора. Эти библиотеки могут быть stdio. ч, строка ч, математика ч и т. д.

    #include "path-to-file/filename"

    используется, когда вы хотите использовать свой собственный файл заголовка, который находится в папке вашего проекта или где-то еще.

    Для получения дополнительной информации о препроцессорах и заголовке. Читать C - Препроцессоры .

    ответ дан Hafiz Shehbaz Ali, с репутацией 1502, 2.04.2015
  • 0 рейтинг
      #include    (1)     
      #include "filename"   (2)
    

    #include включает исходный файл, идентифицируемый по имени файла, в текущий исходный файл в строке сразу после директивы.

    Первая версия директивы поиска только стандартного включает каталоги. Стандартная библиотека C ++, а также стандартная библиотека C, неявно включен в стандартные каталоги включения. Стандарт каталоги include могут контролироваться пользователем через компилятор опции.

    Вторая версия сначала ищет каталог, в котором находится текущий файл находится и, только если файл не найден, ищет стандарт включить каталоги.

    В случае, если файл не найден, программа некорректно сформирована.

    ответ дан S. M. AMRAN, с репутацией 192, 7.01.2017
  • 0 рейтинг

    Чтобы включить предопределенный файл заголовка библиотеки, используется #include, тогда как для включения пользовательского файла заголовка #include "filename" имеет значение.

    ответ дан Vikranth Inti, с репутацией 60, 22.06.2016
  • 0 рейтинг

    «& lt; filename & gt;» выполняет поиск в стандартных местах библиотеки C

    , тогда как «filename» выполняет поиск и в текущем каталоге.

    В идеале вы должны использовать & lt ;. , , & GT; для стандартных библиотек C и ". , , msgstr "для библиотек, которые вы пишете и присутствует в текущем каталоге.

    ответ дан jigar karangiya, с репутацией 69, 28.03.2018
  • 0 рейтинг

    Единственный способ узнать это - прочитать документацию вашей реализации.

    В C стандарт , раздел 6. 10. 2, параграфы 2-4 заявляют:

    • Директива предварительной обработки вида

      #include  new-line
      

      ищет последовательность мест, определенных реализацией, для заголовка, уникально идентифицированного указанной последовательностью между разделителями < и >, и вызывает замену этой директивы всем содержимым заголовка. Как места определяются или как определяется заголовок, определяется реализацией.

    • Директива предварительной обработки вида

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

      вызывает замену этой директивы всем содержимым исходного файла, идентифицируемого указанной последовательностью между разделителями ". Именованный исходный файл ищется в соответствии с реализацией. Если этот поиск не поддерживается или поиск не удался, директива обрабатывается повторно, как если бы она читала

      #include  new-line
      

      с идентичной содержащейся последовательностью (включая > символа, если есть) из оригинала директивы.

    • Директива предварительной обработки вида

      #include pp-tokens new-line
      

      (который не соответствует ни одной из двух предыдущих форм) разрешен. Токены предварительной обработки после include в директиве обрабатываются так же, как и в обычном тексте. (Каждый идентификатор, определенный в настоящее время как имя макроса, заменяется своим списком замены токенов предварительной обработки. ) Директива, возникающая после всех замен, должна соответствовать одной из двух предыдущих форм. Метод, с помощью которого последовательность токенов предварительной обработки между парой токенов предварительной обработки < и > или парой символов " объединяется в один токен предварительной обработки имени заголовка, определяется реализацией.

    Определения:

    • h-char: любой элемент исходного набора символов, кроме символа новой строки и >

    • q-char: любой элемент исходного набора символов, кроме символа новой строки и "

    ответ дан piCookie, с репутацией 6997, 16.09.2008
  • 0 рейтинг

    Некоторые хорошие ответы здесь ссылаются на стандарт C, но забыл стандарт POSIX, особенно специфическое поведение C99 (e. г. C компилятор) команда.

    Согласно Базовые спецификации открытых групп, выпуск 7 ,

    -I справочник

    Измените алгоритм поиска заголовков, чьи имена не являются абсолютными путями, чтобы искать в каталоге, названном путём имени каталога , прежде чем искать в обычных местах. Таким образом, заголовки, имена которых заключены в двойные кавычки (""), сначала должны быть найдены в каталоге файла со строкой #include , затем в каталогах, названных в опциях -I , и последними в обычных мест. Для заголовков, имена которых заключены в угловые скобки ("& lt; & gt;"), заголовок следует искать только в каталогах, названных в опциях -I , а затем в обычных местах. Каталоги, названные в опциях -I , должны быть найдены в указанном порядке. Реализации должны поддерживать как минимум десять экземпляров этой опции в одном вызове команды c99 .

    Итак, в POSIX-совместимой среде с POSIX-совместимым C-компилятором #include "file.h", скорее всего, сначала будет искать ./file.h, где . - это каталог, где находится файл с оператором #include, а #include , скорее всего, будет искать /usr/include/file.h. во-первых, где /usr/include - это ваша система, определенная обычными местами для заголовков (кажется, это не определено POSIX).

    ответ дан Yann Droneaud, с репутацией 3745, 20.07.2012
  • 0 рейтинг

    Порядок файлов заголовка поиска отличается. & Lt; XXX. ч & GT; предпочитайте сначала искать стандартные заголовки, пока "XXX. h "сначала ищет файлы заголовков рабочей области.

    ответ дан Ezio, с репутацией 518, 20.06.2013
  • 0 рейтинг

    Документация GCC говорит следующее о разнице между ними:

    И пользовательские, и системные заголовочные файлы включены с использованием директивы предварительной обработки ‘#include’ . Имеет два варианта:

    #include

    Этот вариант используется для системных заголовочных файлов. Он ищет файл с именем file в стандартном списке системных каталогов. Вы можете добавить каталоги к этому списку с помощью опции -I (см. Вызов ).

    #include "file"

    Этот вариант используется для заголовочных файлов вашей собственной программы. Он ищет файл с именем file сначала в каталоге, содержащем текущий файл, затем в каталогах с цитатами, а затем в тех же каталогах, которые использовались для . Вы можете добавить каталоги в список каталогов котировок с опцией -iquote. Аргумент ‘#include’, разделенный ли кавычками или угловыми скобками, ведет себя как строковая константа, в которой комментарии не распознаются, а имена макросов не раскрываются. Таким образом, #include указывает включение системного заголовочного файла с именем x/*y.

    Однако, если в файле происходит обратная косая черта, они считаются обычными текстовыми символами, а не escape-символами. Ни одна из escape-последовательностей символов, соответствующих строковым константам в C, не обрабатывается. Таким образом, #include "x\n\\y" указывает имя файла, содержащее три обратных слеша. (Некоторые системы интерпретируют ‘\’ как разделитель пути. Все они также интерпретируют ‘/’ одинаково. Это самый портативный для использования только ‘/’. )

    Ошибка, если в строке после имени файла есть что-либо (кроме комментариев).

    ответ дан Suraj Jain, с репутацией 2022, 14.01.2017
  • 0 рейтинг
    #include 
    

    используется для включения файлов стандартной библиотеки. Таким образом, компилятор проверит места, где находятся стандартные заголовки библиотеки.

    #include "xyz.h"
    

    сообщит компилятору о включении пользовательских заголовочных файлов. Таким образом, компилятор проверит наличие этих заголовочных файлов в текущей папке или в -I определенных папках.

    ответ дан Christy Wald, с репутацией 118, 23.01.2017
  • 0 рейтинг

    include указывает препроцессору искать в -I каталогах и в предопределенных каталогах сначала , затем в. Каталог с файлом. Включение "file" включает препроцессор для поиска в каталоге исходного файла сначала , а затем возвращается к -I и предварительно определенному. Все пункты назначения в любом случае ищутся, только порядок поиска отличается.

    Стандарт 2011 года в основном обсуждает включаемые файлы в "16. 2 Включение исходного файла ".

    2 Директива предварительной обработки вида

    # include new-line

    ищет последовательность мест, определенных реализацией, для заголовка, уникально идентифицируемого указанная последовательность между & lt; и & gt; разделители, и вызывает замена этой директивы всем содержимым заголовка. Как определяются места или как определяется заголовок реализации.

    3 Директива предварительной обработки вида

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

    вызывает замену этой директивы всем содержимым исходного файла, идентифицированным указана последовательность между «разделителями». Именованный исходный файл искал в определенной реализации. Если этот поиск не поддерживается, или если поиск не удался, директива обрабатывается как если читать

    # include new-line

    с идентичной содержащейся последовательностью (включая символы & gt; если есть) из исходной директивы.

    Обратите внимание, что форма "xxx" ухудшается до формы , если файл не найден. Остальное определяется реализацией.

    ответ дан Arkadiy, с репутацией 17461, 3.09.2008
  • 0 рейтинг

    Существует два способа написания оператора #include. Это:

    #include"filename"
    #include
    

    Значение каждой формы -

    #include"mylib.h"
    

    Эта команда будет искать файл mylib.h в текущем каталоге, а также указанный список каталогов, как упомянуто во включенном пути поиска, который мог быть установлен.

    #include
    

    Эта команда будет искать файл mylib.h только в указанном списке каталогов.

    Путь поиска для включения - это не что иное, как список каталогов, в которых будет выполняться поиск включаемого файла. Разные компиляторы Си позволяют задавать путь поиска по-разному.

    ответ дан Noshiii, с репутацией 117, 18.08.2018
  • 0 рейтинг

    #include сообщает компилятору о поиске заголовка в его каталоге "includes", т.е. г. для MinGW компилятор будет искать file.h в C: \ MinGW \ include \ или везде, где установлен ваш компилятор.

    #include "file" говорит компилятору искать в текущем каталоге (т.е. е. каталог, в котором находится исходный файл) для file.

    Вы можете использовать флаг -I для GCC, чтобы сказать ему, что, когда он встречает включение с угловыми скобками, он должен также искать заголовки в каталоге после -I. GCC будет обрабатывать каталог после флага, как если бы это был каталог includes.

    Например, если у вас есть файл с именем myheader.h в вашем собственном каталоге, вы можете сказать #include , если вы вызвали GCC с флагом -I . (указывая, что он должен искать включения в текущем каталоге. )

    Без флага -I вам придется использовать #include "myheader.h", чтобы включить файл, или переместить myheader.h в каталог include вашего компилятора.

    ответ дан Adrian Zhang, с репутацией 338, 11.03.2018
  • 0 рейтинг

    На практике разница заключается в том, где препроцессор ищет включенный файл.

    Для #include препроцессор выполняет поиск в зависимости от реализации, обычно в каталогах поиска, предварительно назначенных компилятором / IDE. Этот метод обычно используется для включения стандартных заголовочных файлов библиотеки.

    Для #include "filename" препроцессор сначала выполняет поиск в том же каталоге, что и файл, содержащий директиву, а затем следует пути поиска, используемому для формы #include . Этот метод обычно используется для включения файлов заголовков, определенных программистом.

    Более полное описание доступно в документации GCC по путям поиска .

    ответ дан quest49, с репутацией 20432, 22.08.2008
  • 0 рейтинг

    Последовательность символов между & lt; и & gt; уникально относится к заголовку, который не обязательно является файлом. Реализации в значительной степени свободны использовать последовательность символов по своему желанию. (В основном, однако, просто обработайте его как имя файла и выполните поиск в , включив путь , как указано в других сообщениях). )

    Если используется форма #include "file", реализация сначала ищет файл с заданным именем, если это поддерживается. Если нет (поддерживается) или если поиск не удался, реализация ведет себя так, как если бы использовалась другая форма (#include ).

    Также существует третья форма, которая используется, когда директива #include не соответствует ни одной из форм выше. В этой форме некоторая базовая предварительная обработка (например, расширение макроса) выполняется для «операндов» директивы #include, и ожидается, что результат будет соответствовать одной из двух других форм.

    ответ дан aib, с репутацией 32690, 8.09.2008
  • 0 рейтинг

    #include используется при обращении к системному файлу. Это заголовочный файл, который можно найти в системных местах по умолчанию, таких как /usr/include или /usr/local/include. Для ваших собственных файлов, которые должны быть включены в другую программу, вы должны использовать синтаксис #include "filename".

    ответ дан srsci, с репутацией 141, 27.08.2014
  • 0 рейтинг

    Я считаю, что заголовки, включенные в двойные кавычки, будут искать в тех же системных путях, что и угловые скобки, если они не найдены в текущем каталоге.

    ответ дан mellis, с репутацией 1155, 1.09.2008
  • 0 рейтинг

    #include с угловыми скобками будет искать «список мест, зависящий от реализации» (что очень сложно сказать «системные заголовки») для файла, который будет включен.

    #include с кавычками будет просто искать файл (и, "в зависимости от реализации", bleh). Это означает, что на обычном английском языке, он будет пытаться применить путь / имя файла, который вы выбрасываете в нем, и не будет предварять системный путь или вмешиваться в него в противном случае.

    Кроме того, в случае сбоя #include "" он перечитывается как #include & lt; & gt; по стандарту.

    Документация gcc имеет (специфичное для компилятора) описание, которое, хотя и относится к gcc, а не к стандарту, намного проще для понимания, чем разговоры о стандартах ISO в стиле адвоката.

    ответ дан Damon, с репутацией 49505, 8.02.2011
  • 0 рейтинг

    Когда вы используете #include & lt; filename & gt;, препроцессор ищет файл в директории заголовочных файлов C \ C ++ (stdio. h \ cstdio, строка, вектор и т. д. ). Но, когда вы используете #include «filename»: сначала препроцессор ищет файл в текущем каталоге, а если его нет - ищет его в каталоге заголовочных файлов C \ C ++.

    ответ дан Chayim Friedman, с репутацией 877, 12.04.2018
  • 0 рейтинг

    Форма 1 - #include "xxx"

    Сначала выполняется поиск наличия заголовочного файла в текущем каталоге, из которого вызывается директива. Если он не найден, выполняется поиск в предварительно сконфигурированном списке стандартных системных каталогов.

    Форма 2 - #include & lt; ххх & gt;

    Это ищет наличие файла заголовка в текущем каталоге, откуда вызывается директива.


    Точный список каталогов поиска зависит от целевой системы, способа настройки GCC и места его установки. Вы можете найти список каталогов поиска вашего компилятора GCC, запустив его с опцией -v.

    Вы можете добавить дополнительные каталоги в путь поиска с помощью - I dir , который заставляет искать dir после текущего каталога (для формы директивы в кавычках) и перед стандартными системными каталогами.


    По сути, форма "xxx" - это не что иное, как поиск в текущем каталоге; если не найдено, возвращается форма

    ответ дан Darshan L, с репутацией 102, 17.08.2018
  • 0 рейтинг

    По стандарту - да, они разные:

    • Директива предварительной обработки вида

      #include  new-line
      

      ищет последовательность мест, определенных реализацией, для заголовка, уникально идентифицированного указанной последовательностью между разделителями < и >, и вызывает замену этой директивы всем содержимым заголовка. Как места определяются или как определяется заголовок, определяется реализацией.

    • Директива предварительной обработки вида

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

      вызывает замену этой директивы всем содержимым исходного файла, идентифицируемого указанной последовательностью между разделителями ". Именованный исходный файл ищется в соответствии с реализацией. Если этот поиск не поддерживается или поиск не удался, директива обрабатывается повторно, как если бы она читала

      #include  new-line
      

      с идентичной содержащейся последовательностью (включая > символа, если есть) из оригинала директивы.

    • Директива предварительной обработки вида

      #include pp-tokens new-line
      

      (который не соответствует ни одной из двух предыдущих форм) разрешен. Токены предварительной обработки после include в директиве обрабатываются так же, как и в обычном тексте. (Каждый идентификатор, определенный в настоящее время как имя макроса, заменяется своим списком замены токенов предварительной обработки. ) Директива, возникающая после всех замен, должна соответствовать одной из двух предыдущих форм. Метод, с помощью которого последовательность токенов предварительной обработки между парой токенов предварительной обработки < и > или парой символов " объединяется в один токен предварительной обработки имени заголовка, определяется реализацией.

    Определения:

    • h-char: любой элемент исходного набора символов, кроме символа новой строки и >

    • q-char: любой элемент исходного набора символов, кроме символа новой строки и "

    Обратите внимание, что в стандарте не говорится о какой-либо связи между способами, определяемыми реализацией. Первая форма ищет одним способом, определяемым реализацией, а другой - способом (возможно, другим), определяемым реализацией. Стандарт также указывает, что должны присутствовать определенные включаемые файлы (например, ).

    Формально вам нужно прочитать руководство для вашего компилятора, однако обычно (по традиции) форма #include "..." выполняет поиск в каталоге файла, в котором сначала был найден #include, а затем в каталогах, которые ищет форма #include <...> (путь включения Например, системные заголовки.

    ответ дан skyking, с репутацией 9957, 18.08.2015
  • 0 рейтинг
    #include "filename" // User defined header
    #include  // Standard library header.
    

    Пример:

    Имя файла здесь Seller.h:

    #ifndef SELLER_H     // Header guard
    #define SELLER_H     // Header guard
    
    #include 
    #include 
    #include 
    
    class Seller
    {
        private:
            char name[31];
            double sales_total;
    
        public:
            Seller();
            Seller(char[], double);
            char*getName();
    
    #endif
    

    В реализации класса (например, Seller.cpp и в других файлах, которые будут использовать файл Seller.h), теперь должен быть включен заголовок, определенный пользователем, следующим образом:

    #include "Seller.h"
    
    ответ дан Barbara, с репутацией 87, 28.09.2011
  • 0 рейтинг

    По крайней мере для версии GCC & lt; = 3. 0, форма угловых скобок не создает зависимости между включенным файлом и включающим файлом.

    Итак, если вы хотите сгенерировать правила зависимости (используя опцию GCC -M для примера), вы должны использовать форму в кавычках для файлов, которые должны быть включены в дерево зависимостей.

    (см. http: // gcc. гну. орг / onlinedocs / CPP / Призвание. HTML )

    ответ дан Denis Ros, с репутацией 129, 25.10.2011
  • 0 рейтинг

    #include

    найдет соответствующий файл из библиотеки C ++. это означает, что если у вас есть файл с именем привет. h в папке библиотеки C ++, #include загрузит его.

    Но,

    #include "filename"

    найдет файл в том же каталоге, где находится ваш исходный файл.

    Кроме того,

    #include "path_to_file/filename"

    найдет файл в каталоге, который вы ввели path_to_file.

    ответ дан virat, с репутацией 81, 21.05.2016
  • 0 рейтинг

    Спасибо за отличные ответы, особенно Адам Стельмащик и ПиКуки, и аиб.

    Как и многие программисты, я использовал неофициальное соглашение об использовании формы "myApp.hpp" для файлов приложения и формы для файлов библиотеки и системы компилятора, т.е. е. файлы, указанные в /I и переменной среды INCLUDE, в течение многих лет считая, что это стандарт.

    Однако в стандарте C говорится, что порядок поиска зависит от реализации, что может усложнить переносимость. Что еще хуже, мы используем jam, который автоматически определяет местонахождение включаемых файлов. Вы можете использовать относительные или абсолютные пути для ваших включаемых файлов. я. е.

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

    Более старые версии MSVS требовали двойной обратной косой черты (\\), но теперь это не требуется. Я не знаю, когда это изменилось. Просто используйте косую черту для совместимости с 'nix (Windows примет это).

    Если действительно беспокоит по этому поводу , используйте "./myHeader.h" для включаемого файла в том же каталоге, что и исходный код (мой текущий, очень большой проект имеет несколько дублирующихся имен включаемых файлов, разбросанных по всему - действительно проблема управления конфигурацией).

    Вот пояснение MSDN (, скопированное здесь для вашего удобства).

    Цитируемая форма

    Препроцессор ищет включаемые файлы в следующем порядке:

    1. В том же каталоге, что и файл, содержащий инструкцию #include.
    2. В каталоги открытых в данный момент включаемых файлов, в обратном порядке, в которых
      они были открыты. Поиск начинается в каталоге родительского включаемого файла и
      продолжается вверх по каталогам любых включаемых файлов прародителя.
    3. По пути, указанному каждым параметром компилятора /I.
    4. Вдоль путей, указанных в переменной среды INCLUDE.

    Форма углового кронштейна

    Препроцессор ищет включаемые файлы в следующем порядке:

    1. По пути, указанному каждым параметром компилятора /I.
    2. Когда компиляция происходит в командной строке, по путям, указанным в переменной среды INCLUDE.
    ответ дан riderBill, с репутацией 484, 14.10.2014
  • 0 рейтинг

    Простое общее правило заключается в использовании угловых скобок для включения заголовочных файлов, которые поставляются с компилятором. Используйте двойные кавычки, чтобы включить любые другие заголовочные файлы. Большинство компиляторов делают это таким образом.

    1. 9 - Заголовочные файлы объясняет более подробно о директивах препроцессора. Если вы начинающий программист, эта страница должна помочь вам понять все это. Я узнал об этом здесь, и я следил за этим на работе.

    ответ дан Eakan Gopalakrishnan, с репутацией 486, 4.06.2013
  • 0 рейтинг
    • #include <> для предопределенных заголовочных файлов

    Если файл заголовка задан заранее, вы просто пишете имя файла заголовка в угловых скобках, и это будет выглядеть так (при условии, что у нас есть предопределенное имя файла заголовка iostream):

    #include 
    
    • #include " " - для заголовочных файлов, которые программист определяет

    Если вы (программист) написали свой собственный файл заголовка, вы бы написали имя файла заголовка в кавычках. Итак, предположим, что вы написали заголовочный файл с именем myfile.h, тогда это пример того, как вы будете использовать директиву include для включения этого файла:

    #include "myfile.h"
    
    ответ дан MobiDev, с репутацией 1700, 17.12.2012
  • 0 рейтинг

    В C ++ включить файл можно двумя способами:

    Первый из них - #include, который указывает препроцессору искать файл в предопределенном местоположении по умолчанию. Это местоположение часто является переменной среды INCLUDE, которая обозначает путь для включения файлов.

    И второй тип - #include «filename», который указывает препроцессору сначала искать файл в текущем каталоге, а затем искать его в предопределенных местоположениях, установленных пользователем.

    ответ дан virat, с репутацией 81, 17.02.2016
  • 0 рейтинг

    Многие ответы здесь сосредоточены на путях, которые компилятор будет искать, чтобы найти файл. Хотя это то, что делает большинство компиляторов, компилятор-исполнитель может быть предварительно запрограммирован с эффектами стандартных заголовков и обрабатывать, скажем, #include как переключатель, и он вообще не должен существовать как файл.

    Это не чисто гипотетически. Есть по крайней мере один компилятор, который работает таким образом. Рекомендуется использовать #include только со стандартными заголовками.

    ответ дан sp2danny, с репутацией 4758, 25.02.2014
  • 0 рейтинг

    Это делает:

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

    с ., являющимся либо каталогом файла, в котором содержится #include, и / или текущим рабочим каталогом компилятора, и / или default_include_paths

    и

     is short for /mypath/myfile
    

    Если ./ находится в , то это не имеет значения.

    Если mypath/myfile находится в другом каталоге включения, поведение не определено.

    ответ дан Stefan Steiger, с репутацией 42348, 8.02.2011
  • 0 рейтинг

    Для #include "" компилятор обычно выполняет поиск в папке файла, который содержит эту папку, а затем и другие папки. Для #include <> компилятор не ищет папку текущего файла.

    ответ дан Maxim Egorushkin, с репутацией 80844, 8.02.2011