В чем разница между #import и #include в Objective-C?

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

По сути, вам решать, что именно вы хотите использовать. Я стараюсь # импортировать заголовки для вещей Objective-C (например, определения классов и т. Д.) И # включать стандартные материалы C, которые мне нужны. Например, один из моих исходных файлов может выглядеть так:

#import <Foundation/Foundation.h>

#include <asl.h>
#include <mach/mach.h>

Кажется, существует большая путаница в отношении препроцессора.

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

Итак, если у вас есть файл a.h с таким содержимым:

typedef int my_number;

и файл b.c с таким содержанием:

#include "a.h"
#include "a.h"

файл b.c будет преобразован препроцессором перед компиляцией в

typedef int my_number;
typedef int my_number;

что приведет к ошибке компилятора, поскольку тип my_number определен дважды. Несмотря на то, что определение такое же, это не допускается языком C.

Поскольку заголовок часто используется более чем в одном месте, include guards обычно используются в C. Это выглядит так:

 #ifndef _a_h_included_
 #define _a_h_included_

 typedef int my_number;

 #endif

Файл b.c по-прежнему будет содержать все содержимое заголовка дважды после предварительной обработки. Но второй экземпляр будет проигнорирован, поскольку макрос _a_h_included_ уже был бы определен.

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

Objective-C имеет инструкцию препроцессора #import (ее также можно использовать для кода C и C ++ с некоторыми компиляторами и параметрами). Это почти то же самое, что и #include, но также внутренне отмечает, какой файл уже был включен. Строка #import заменяется содержимым указанного файла только при первом обнаружении. Каждый раз после этого просто игнорируется.

Я согласен с Джейсоном.

Меня поймали на этом:

#import <sys/time.h>  // to use gettimeofday() function
#import <time.h>      // to use time() function

Что касается GNU gcc, он постоянно жаловался, что функция time () не определена.

Затем я изменил #import на #include, и все прошло нормально.

Причина:

Вы #import ‹sys / time.h›:
‹sys / time.h› включает только часть ‹time.h› с помощью #defines

Вы #import ‹time.h›:
Не пойдем. Несмотря на то, что уже была включена только часть ‹time.h›,
что касается #import, этот файл теперь уже полностью включен.

Нижняя линия:

Заголовки C / C ++ традиционно включают части других включаемых файлов.
Поэтому для заголовков C / C ++ используйте #include.
Для заголовков objc / objc ++ используйте #import.

#include работает так же, как C #include.

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

Суть в том, чтобы просто использовать #import в Objective-C и не беспокойтесь, если ваши заголовки импортируют что-то более одного раза.

Я знаю, что эта ветка устарела ... но в «современное время» ... существует гораздо более совершенная «стратегия включения» через @import модули clang - это часто упускается из виду ..

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

@import Darwin; // Like including all of /usr/include. @see /usr/include/module.map

or

@import Foundation;  //  Like #import <Foundation/Foundation.h>
@import ObjectiveC;  //  Like #import <objc/runtime.h>

Однако этот импорт модуля ведет себя совершенно иначе, чем соответствующий #include: когда компилятор видит импорт модуля выше, он загружает двоичное представление модуля и делает его API напрямую доступным для приложения. Определения препроцессора, предшествующие объявлению импорта, не влияют на предоставленный API ... потому что сам модуль был скомпилирован как отдельный автономный модуль. Кроме того, любые флаги компоновщика, необходимые для использования модуля, будут автоматически предоставлены при импорте модуля. Эта семантическая модель импорта решает многие проблемы модели включения препроцессора.

Чтобы включить модули, передайте флаг командной строки -fmodules или CLANG_ENABLE_MODULES в Xcode- во время компиляции. Как упоминалось выше .. эта стратегия устраняет ВСЕ и ВСЕ LDFLAGS. Например, вы можете УДАЛИТЬ любые настройки "OTHER_LDFLAGS", а также любые этапы "Связывание" ..

Я считаю, что время компиляции / запуска "кажется" гораздо более быстрым (или, возможно, просто меньше задержек при "связывании"?) .. а также дает прекрасную возможность очистить теперь посторонний файл Project-Prefix.pch, и соответствующие настройки сборки, GCC_INCREASE_PRECOMPILED_HEADER_SHARING, GCC_PRECOMPILE_PREFIX_HEADER, GCC_PREFIX_HEADER и т. д.

Кроме того, хотя это и не очень хорошо документировано ... Вы можете создавать module.maps для своих собственных фреймворков и включать их таким же удобным способом. Вы можете взглянуть на мой репозиторий github ObjC-Clang-Modules для некоторых примеров того, как реализовать такие чудеса. .

Если вы знакомы с C ++ и макросами, то

#import "Class.h" 

похож на

{
#pragma once

#include "class.h"
}

Это означает, что ваш класс будет загружен только один раз при запуске вашего приложения.

Возможно, у меня была глобальная переменная в одном из моих .h файлов, которая вызвала проблему, и я решил ее, добавив перед ней extern.

ЕСЛИ вы # включаете файл два раза в файлы .h, компилятор выдаст ошибку. Но если вы # импортируете файл более одного раза, компилятор проигнорирует его.